tmp
diff --git a/hbase-thrift/pom.xml b/hbase-thrift/pom.xml
new file mode 100644
index 0000000..7b71097
--- /dev/null
+++ b/hbase-thrift/pom.xml
@@ -0,0 +1,232 @@
+<?xml version="1.0"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <!--
+ /**
+ * 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.
+ */
+ -->
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.apache.hbase.connectors</groupId>
+ <artifactId>hbase-connectors</artifactId>
+ <version>${revision}</version>
+ <relativePath>../</relativePath>
+ </parent>
+ <artifactId>hbase-thrift</artifactId>
+ <packaging>jar</packaging>
+ <name>Apache HBase - Thrift</name>
+ <description>HBase Thrift Server</description>
+ <properties>
+ <thrift.version>0.14.1</thrift.version>
+ </properties>
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.thrift</groupId>
+ <artifactId>libthrift</artifactId>
+ <version>${thrift.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.hbase</groupId>
+ <artifactId>hbase-client</artifactId>
+ </dependency>
+ </dependencies>
+ <build>
+ <resources>
+ <!-- Add the build webabpps to the classpth -->
+ <resource>
+ <directory>${project.build.directory}</directory>
+ <includes>
+ <include>hbase-webapps/**</include>
+ </includes>
+ </resource>
+ <resource>
+ <directory>src/main/resources/</directory>
+ <includes>
+ <include>**/*.thrift</include>
+ </includes>
+ </resource>
+ </resources>
+ <plugins>
+ <!-- General ant tasks, bound to different build phases -->
+ <plugin>
+ <artifactId>maven-antrun-plugin</artifactId>
+ <executions>
+ <!-- Generate web app sources -->
+ <execution>
+ <id>generate</id>
+ <goals>
+ <goal>run</goal>
+ </goals>
+ <phase>generate-sources</phase>
+ <configuration>
+ <target>
+ <property location="${project.build.directory}/hbase-webapps" name="build.webapps"/>
+ <property location="${basedir}/src/main/resources/hbase-webapps" name="src.webapps"/>
+ <property location="${project.build.directory}/generated-sources" name="generated.sources"/>
+ <mkdir dir="${build.webapps}"/>
+ <copy todir="${build.webapps}">
+ <fileset dir="${src.webapps}">
+ <exclude name="**/*.jsp"/>
+ <exclude name="**/.*"/>
+ <exclude name="**/*~"/>
+ </fileset>
+ </copy>
+ <!--The compile.classpath is passed in by maven -->
+ <taskdef classname="org.apache.jasper.JspC" classpathref="maven.compile.classpath" name="jspcompiler"/>
+ <mkdir dir="${build.webapps}/thrift/WEB-INF"/>
+ <jspcompiler outputdir="${generated.sources}/java" package="org.apache.hadoop.hbase.generated.thrift" uriroot="${src.webapps}/thrift" webxml="${build.webapps}/thrift/WEB-INF/web.xml"/>
+ </target>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <executions>
+ <!-- Add the generated sources -->
+ <execution>
+ <id>jspcSource-packageInfo-source</id>
+ <goals>
+ <goal>add-source</goal>
+ </goals>
+ <phase>generate-sources</phase>
+ <configuration>
+ <sources>
+ <source>${project.build.directory}/generated-sources/java</source>
+ </sources>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <!-- Make a jar and put the sources in the jar -->
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-source-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+ <profiles>
+ <!--
+ Profile for regenerating the thrift java classes.
+ The generated files are to be committed to version control.
+ Activate using:
+ mvn compile -Pcompile-thrift
+ -->
+ <profile>
+ <id>compile-thrift</id>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-enforcer-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>enforce-thrift-version</id>
+ <goals>
+ <goal>enforce</goal>
+ </goals>
+ <configuration>
+ <rules>
+ <requireProperty>
+ <property>thrift.version</property>
+ <message>"The Thrift version must be specified."</message>
+ <regex>0\.14\.1</regex>
+ <regexMessage>-
+-
+[FATAL] ==========================================================================================
+[FATAL] HBase Thrift requires the thrift generator version 0.14.1.
+[FATAL] Setting it to something else needs to be reviewed for wire and behavior compatibility.
+[FATAL] ==========================================================================================
+-
+-</regexMessage>
+ </requireProperty>
+ </rules>
+ <fail>true</fail>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>exec-maven-plugin</artifactId>
+ <version>${exec.maven.version}</version>
+ <executions>
+ <execution>
+ <id>check-thrift-version</id>
+ <goals>
+ <goal>exec</goal>
+ </goals>
+ <phase>generate-sources</phase>
+ <configuration>
+ <executable>sh</executable>
+ <workingDirectory>${basedir}</workingDirectory>
+ <arguments>
+ <argument>-c</argument>
+ <argument>${thrift.path} -version | \
+ fgrep 'Thrift version ${thrift.version}' && exit 0;
+ echo "========== [FATAL] Need Thrift version ${thrift.version} ==========";
+ exit 1</argument>
+ </arguments>
+ </configuration>
+ </execution>
+ <execution>
+ <id>thrift</id>
+ <goals>
+ <goal>exec</goal>
+ </goals>
+ <phase>generate-sources</phase>
+ <configuration>
+ <executable>${thrift.path}</executable>
+ <workingDirectory>${basedir}</workingDirectory>
+ <arguments>
+ <argument>-strict</argument>
+ <argument>--gen</argument>
+ <argument>java</argument>
+ <argument>-out</argument>
+ <argument>${basedir}/src/main/java</argument>
+ <argument>${basedir}/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift</argument>
+ </arguments>
+ </configuration>
+ </execution>
+ <execution>
+ <id>thrift2</id>
+ <goals>
+ <goal>exec</goal>
+ </goals>
+ <phase>generate-sources</phase>
+ <configuration>
+ <executable>${thrift.path}</executable>
+ <workingDirectory>${basedir}</workingDirectory>
+ <arguments>
+ <argument>-strict</argument>
+ <argument>--gen</argument>
+ <argument>java</argument>
+ <argument>-out</argument>
+ <argument>${basedir}/src/main/java</argument>
+ <argument>${basedir}/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift</argument>
+ </arguments>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ </profiles>
+</project>
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/CallQueue.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/CallQueue.java
new file mode 100644
index 0000000..145e25f
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/CallQueue.java
@@ -0,0 +1,256 @@
+/*
+ * 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.thrift;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A BlockingQueue reports waiting time in queue and queue length to ThriftMetrics.
+ */
+@InterfaceAudience.Private
+public class CallQueue implements BlockingQueue<Runnable> {
+ private static final Logger LOG = LoggerFactory.getLogger(CallQueue.class);
+
+ private final BlockingQueue<Call> underlyingQueue;
+ private final ThriftMetrics metrics;
+
+ public CallQueue(BlockingQueue<Call> underlyingQueue, ThriftMetrics metrics) {
+ this.underlyingQueue = underlyingQueue;
+ this.metrics = metrics;
+ }
+
+ private static long now() {
+ return System.nanoTime();
+ }
+
+ public static class Call implements Runnable {
+ final long startTime;
+ final Runnable underlyingRunnable;
+
+ Call(Runnable underlyingRunnable) {
+ this.underlyingRunnable = underlyingRunnable;
+ this.startTime = now();
+ }
+
+ @Override
+ public void run() {
+ underlyingRunnable.run();
+ }
+
+ public long timeInQueue() {
+ return now() - startTime;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (other instanceof Call) {
+ Call otherCall = (Call) (other);
+ return this.underlyingRunnable.equals(otherCall.underlyingRunnable);
+ } else if (other instanceof Runnable) {
+ return this.underlyingRunnable.equals(other);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return this.underlyingRunnable.hashCode();
+ }
+ }
+
+ @Override
+ public Runnable poll() {
+ Call result = underlyingQueue.poll();
+ updateMetrics(result);
+ return result;
+ }
+
+ private void updateMetrics(Call result) {
+ if (result == null) {
+ return;
+ }
+ metrics.incTimeInQueue(result.timeInQueue());
+ metrics.setCallQueueLen(this.size());
+ }
+
+ @Override
+ public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
+ Call result = underlyingQueue.poll(timeout, unit);
+ updateMetrics(result);
+ return result;
+ }
+
+ @Override
+ public Runnable remove() {
+ Call result = underlyingQueue.remove();
+ updateMetrics(result);
+ return result;
+ }
+
+ @Override
+ public Runnable take() throws InterruptedException {
+ Call result = underlyingQueue.take();
+ updateMetrics(result);
+ return result;
+ }
+
+ @Override
+ public int drainTo(Collection<? super Runnable> destination) {
+ return drainTo(destination, Integer.MAX_VALUE);
+ }
+
+ @Override
+ public int drainTo(Collection<? super Runnable> destination, int maxElements) {
+ if (destination == this) {
+ throw new IllegalArgumentException("A BlockingQueue cannot drain to itself.");
+ }
+ List<Call> drained = new ArrayList<>();
+ underlyingQueue.drainTo(drained, maxElements);
+ for (Call r : drained) {
+ updateMetrics(r);
+ }
+ destination.addAll(drained);
+ int sz = drained.size();
+ LOG.info("Elements drained: " + sz);
+ return sz;
+ }
+
+ @Override
+ public boolean offer(Runnable element) {
+ return underlyingQueue.offer(new Call(element));
+ }
+
+ @Override
+ public boolean offer(Runnable element, long timeout, TimeUnit unit) throws InterruptedException {
+ return underlyingQueue.offer(new Call(element), timeout, unit);
+ }
+
+ @Override
+ public void put(Runnable element) throws InterruptedException {
+ underlyingQueue.put(new Call(element));
+ }
+
+ @Override
+ public boolean add(Runnable element) {
+ return underlyingQueue.add(new Call(element));
+ }
+
+ @Override
+ public boolean addAll(Collection<? extends Runnable> elements) {
+ int added = 0;
+ for (Runnable r : elements) {
+ added += underlyingQueue.add(new Call(r)) ? 1 : 0;
+ }
+ return added != 0;
+ }
+
+ @Override
+ public Runnable element() {
+ return underlyingQueue.element();
+ }
+
+ @Override
+ public Runnable peek() {
+ return underlyingQueue.peek();
+ }
+
+ @Override
+ public void clear() {
+ underlyingQueue.clear();
+ }
+
+ @Override
+ public boolean containsAll(Collection<?> elements) {
+ return underlyingQueue.containsAll(elements);
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return underlyingQueue.isEmpty();
+ }
+
+ @Override
+ public Iterator<Runnable> iterator() {
+ return new Iterator<Runnable>() {
+ final Iterator<Call> underlyingIterator = underlyingQueue.iterator();
+
+ @Override
+ public Runnable next() {
+ return underlyingIterator.next();
+ }
+
+ @Override
+ public boolean hasNext() {
+ return underlyingIterator.hasNext();
+ }
+
+ @Override
+ public void remove() {
+ underlyingIterator.remove();
+ }
+ };
+ }
+
+ @Override
+ public boolean removeAll(Collection<?> elements) {
+ return underlyingQueue.removeAll(elements);
+ }
+
+ @Override
+ public boolean retainAll(Collection<?> elements) {
+ return underlyingQueue.retainAll(elements);
+ }
+
+ @Override
+ public int size() {
+ return underlyingQueue.size();
+ }
+
+ @Override
+ public Object[] toArray() {
+ return underlyingQueue.toArray();
+ }
+
+ @Override
+ public <T> T[] toArray(T[] array) {
+ return underlyingQueue.toArray(array);
+ }
+
+ @Override
+ public boolean contains(Object element) {
+ return underlyingQueue.contains(element);
+ }
+
+ @Override
+ public int remainingCapacity() {
+ return underlyingQueue.remainingCapacity();
+ }
+
+ @Override
+ public boolean remove(Object element) {
+ return underlyingQueue.remove(element);
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/Constants.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/Constants.java
new file mode 100644
index 0000000..83bb90e
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/Constants.java
@@ -0,0 +1,157 @@
+/*
+ * 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.thrift;
+
+import org.apache.yetus.audience.InterfaceAudience;
+
+/**
+ * Thrift related constants
+ */
+@InterfaceAudience.Private
+public final class Constants {
+ private Constants() {
+ }
+
+ // Jetty's max header size is Character.MAX_VALUE - 1, See ArrayTernaryTrie for more details
+ // And in newer jetty version, they add a check when creating a server so we must follow this
+ // limitation otherwise the UTs will fail
+ public static final int DEFAULT_HTTP_MAX_HEADER_SIZE = Character.MAX_VALUE - 1;
+
+ public static final String SERVER_TYPE_CONF_KEY = "hbase.regionserver.thrift.server.type";
+
+ public static final String COMPACT_CONF_KEY = "hbase.regionserver.thrift.compact";
+ public static final boolean COMPACT_CONF_DEFAULT = false;
+
+ public static final String FRAMED_CONF_KEY = "hbase.regionserver.thrift.framed";
+ public static final boolean FRAMED_CONF_DEFAULT = false;
+
+ public static final String MAX_FRAME_SIZE_CONF_KEY =
+ "hbase.regionserver.thrift.framed.max_frame_size_in_mb";
+ public static final int MAX_FRAME_SIZE_CONF_DEFAULT = 2;
+
+ public static final String COALESCE_INC_KEY = "hbase.regionserver.thrift.coalesceIncrement";
+ public static final String USE_HTTP_CONF_KEY = "hbase.regionserver.thrift.http";
+
+ public static final String HTTP_MIN_THREADS_KEY = "hbase.thrift.http_threads.min";
+ public static final int HTTP_MIN_THREADS_KEY_DEFAULT = 2;
+
+ public static final String HTTP_MAX_THREADS_KEY = "hbase.thrift.http_threads.max";
+ public static final int HTTP_MAX_THREADS_KEY_DEFAULT = 100;
+
+ // ssl related configs
+ public static final String THRIFT_SSL_ENABLED_KEY = "hbase.thrift.ssl.enabled";
+ public static final String THRIFT_SSL_KEYSTORE_STORE_KEY = "hbase.thrift.ssl.keystore.store";
+ public static final String THRIFT_SSL_KEYSTORE_PASSWORD_KEY =
+ "hbase.thrift.ssl.keystore.password";
+ public static final String THRIFT_SSL_KEYSTORE_KEYPASSWORD_KEY =
+ "hbase.thrift.ssl.keystore.keypassword";
+ public static final String THRIFT_SSL_EXCLUDE_CIPHER_SUITES_KEY =
+ "hbase.thrift.ssl.exclude.cipher.suites";
+ public static final String THRIFT_SSL_INCLUDE_CIPHER_SUITES_KEY =
+ "hbase.thrift.ssl.include.cipher.suites";
+ public static final String THRIFT_SSL_EXCLUDE_PROTOCOLS_KEY =
+ "hbase.thrift.ssl.exclude.protocols";
+ public static final String THRIFT_SSL_INCLUDE_PROTOCOLS_KEY =
+ "hbase.thrift.ssl.include.protocols";
+ public static final String THRIFT_SSL_KEYSTORE_TYPE_KEY = "hbase.thrift.ssl.keystore.type";
+ public static final String THRIFT_SSL_KEYSTORE_TYPE_DEFAULT = "jks";
+
+ public static final String THRIFT_SUPPORT_PROXYUSER_KEY = "hbase.thrift.support.proxyuser";
+
+ // kerberos related configs
+ public static final String THRIFT_DNS_INTERFACE_KEY = "hbase.thrift.dns.interface";
+ public static final String THRIFT_DNS_NAMESERVER_KEY = "hbase.thrift.dns.nameserver";
+ public static final String THRIFT_KERBEROS_PRINCIPAL_KEY = "hbase.thrift.kerberos.principal";
+ public static final String THRIFT_KEYTAB_FILE_KEY = "hbase.thrift.keytab.file";
+ public static final String THRIFT_SPNEGO_PRINCIPAL_KEY = "hbase.thrift.spnego.principal";
+ public static final String THRIFT_SPNEGO_KEYTAB_FILE_KEY = "hbase.thrift.spnego.keytab.file";
+
+ /**
+ * Amount of time in milliseconds before a server thread will timeout waiting for client to send
+ * data on a connected socket. Currently, applies only to TBoundedThreadPoolServer
+ */
+ public static final String THRIFT_SERVER_SOCKET_READ_TIMEOUT_KEY =
+ "hbase.thrift.server.socket.read.timeout";
+ public static final int THRIFT_SERVER_SOCKET_READ_TIMEOUT_DEFAULT = 60000;
+
+ /**
+ * Thrift quality of protection configuration key. Valid values can be: auth-conf: authentication,
+ * integrity and confidentiality checking auth-int: authentication and integrity checking auth:
+ * authentication only This is used to authenticate the callers and support impersonation. The
+ * thrift server and the HBase cluster must run in secure mode.
+ */
+ public static final String THRIFT_QOP_KEY = "hbase.thrift.security.qop";
+
+ public static final String BACKLOG_CONF_KEY = "hbase.regionserver.thrift.backlog";
+ public static final int BACKLOG_CONF_DEAFULT = 0;
+
+ public static final String BIND_CONF_KEY = "hbase.regionserver.thrift.ipaddress";
+ public static final String DEFAULT_BIND_ADDR = "0.0.0.0";
+
+ public static final String PORT_CONF_KEY = "hbase.regionserver.thrift.port";
+ public static final int DEFAULT_LISTEN_PORT = 9090;
+
+ public static final String THRIFT_HTTP_ALLOW_OPTIONS_METHOD =
+ "hbase.thrift.http.allow.options.method";
+ public static final boolean THRIFT_HTTP_ALLOW_OPTIONS_METHOD_DEFAULT = false;
+
+ public static final String THRIFT_INFO_SERVER_PORT = "hbase.thrift.info.port";
+ public static final int THRIFT_INFO_SERVER_PORT_DEFAULT = 9095;
+
+ public static final String THRIFT_INFO_SERVER_BINDING_ADDRESS = "hbase.thrift.info.bindAddress";
+ public static final String THRIFT_INFO_SERVER_BINDING_ADDRESS_DEFAULT = "0.0.0.0";
+
+ public static final String THRIFT_QUEUE_SIZE = "hbase.thrift.queue.size";
+ public static final int THRIFT_QUEUE_SIZE_DEFAULT = Integer.MAX_VALUE;
+
+ public static final String THRIFT_SELECTOR_NUM = "hbase.thrift.selector.num";
+
+ public static final String THRIFT_FILTERS = "hbase.thrift.filters";
+
+ // Command line options
+
+ public static final String READ_TIMEOUT_OPTION = "readTimeout";
+ public static final String MIN_WORKERS_OPTION = "minWorkers";
+ public static final String MAX_WORKERS_OPTION = "workers";
+ public static final String MAX_QUEUE_SIZE_OPTION = "queue";
+ public static final String SELECTOR_NUM_OPTION = "selectors";
+ public static final String KEEP_ALIVE_SEC_OPTION = "keepAliveSec";
+ public static final String BIND_OPTION = "bind";
+ public static final String COMPACT_OPTION = "compact";
+ public static final String FRAMED_OPTION = "framed";
+ public static final String PORT_OPTION = "port";
+ public static final String INFOPORT_OPTION = "infoport";
+
+ // for thrift2 server
+ public static final String READONLY_OPTION = "readonly";
+
+ public static final String THRIFT_READONLY_ENABLED = "hbase.thrift.readonly";
+ public static final boolean THRIFT_READONLY_ENABLED_DEFAULT = false;
+
+ public static final String HBASE_THRIFT_CLIENT_SCANNER_CACHING =
+ "hbase.thrift.client.scanner.caching";
+
+ public static final int HBASE_THRIFT_CLIENT_SCANNER_CACHING_DEFAULT = 20;
+
+ public static final String HBASE_THRIFT_SERVER_NAME = "hbase.thrift.server.name";
+ public static final String HBASE_THRIFT_SERVER_PORT = "hbase.thrift.server.port";
+
+ public static final String HBASE_THRIFT_CLIENT_BUIDLER_CLASS =
+ "hbase.thrift.client.builder.class";
+
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HBaseServiceHandler.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HBaseServiceHandler.java
new file mode 100644
index 0000000..5071c6d
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HBaseServiceHandler.java
@@ -0,0 +1,81 @@
+/*
+ * 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.thrift;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.client.Admin;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.security.UserProvider;
+import org.apache.hadoop.hbase.thrift.util.ConnectionCache;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.yetus.audience.InterfaceAudience;
+
+/**
+ * abstract class for HBase handler providing a Connection cache and get table/admin method
+ */
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.TOOLS)
+public abstract class HBaseServiceHandler {
+ public static final String CLEANUP_INTERVAL = "hbase.thrift.connection.cleanup-interval";
+ public static final String MAX_IDLETIME = "hbase.thrift.connection.max-idletime";
+
+ protected Configuration conf;
+
+ protected final ConnectionCache connectionCache;
+
+ public HBaseServiceHandler(final Configuration c, final UserProvider userProvider)
+ throws IOException {
+ this.conf = c;
+ int cleanInterval = conf.getInt(CLEANUP_INTERVAL, 10 * 1000);
+ int maxIdleTime = conf.getInt(MAX_IDLETIME, 10 * 60 * 1000);
+ connectionCache = new ConnectionCache(conf, userProvider, cleanInterval, maxIdleTime);
+ }
+
+ protected ThriftMetrics metrics = null;
+
+ public void initMetrics(ThriftMetrics metrics) {
+ this.metrics = metrics;
+ }
+
+ public void setEffectiveUser(String effectiveUser) {
+ connectionCache.setEffectiveUser(effectiveUser);
+ }
+
+ /**
+ * Obtain HBaseAdmin. Creates the instance if it is not already created.
+ */
+ protected Admin getAdmin() throws IOException {
+ return connectionCache.getAdmin();
+ }
+
+ /**
+ * Creates and returns a Table instance from a given table name. n * name of table
+ * @return Table object
+ * @throws IOException if getting the table fails
+ */
+ protected Table getTable(final byte[] tableName) throws IOException {
+ String table = Bytes.toString(tableName);
+ return connectionCache.getTable(table);
+ }
+
+ protected Table getTable(final ByteBuffer tableName) throws IOException {
+ return getTable(Bytes.getBytes(tableName));
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HThreadedSelectorServerArgs.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HThreadedSelectorServerArgs.java
new file mode 100644
index 0000000..b8a7dda
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HThreadedSelectorServerArgs.java
@@ -0,0 +1,83 @@
+/*
+ * 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.thrift;
+
+import java.util.Locale;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.thrift.server.TThreadedSelectorServer;
+import org.apache.thrift.transport.TNonblockingServerTransport;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A TThreadedSelectorServer.Args that reads hadoop configuration
+ */
+@InterfaceAudience.Private
+public class HThreadedSelectorServerArgs extends TThreadedSelectorServer.Args {
+ private static final Logger LOG = LoggerFactory.getLogger(TThreadedSelectorServer.class);
+
+ /**
+ * Number of selector threads for reading and writing socket
+ */
+ public static final String SELECTOR_THREADS_CONF_KEY = "hbase.thrift.selector.threads";
+
+ /**
+ * Number fo threads for processing the thrift calls
+ */
+ public static final String WORKER_THREADS_CONF_KEY = "hbase.thrift.worker.threads";
+
+ /**
+ * Time to wait for server to stop gracefully
+ */
+ public static final String STOP_TIMEOUT_CONF_KEY = "hbase.thrift.stop.timeout.seconds";
+
+ /**
+ * Maximum number of accepted elements per selector
+ */
+ public static final String ACCEPT_QUEUE_SIZE_PER_THREAD_CONF_KEY =
+ "hbase.thrift.accept.queue.size.per.selector";
+
+ /**
+ * The strategy for handling new accepted connections.
+ */
+ public static final String ACCEPT_POLICY_CONF_KEY = "hbase.thrift.accept.policy";
+
+ public HThreadedSelectorServerArgs(TNonblockingServerTransport transport, Configuration conf) {
+ super(transport);
+ readConf(conf);
+ }
+
+ private void readConf(Configuration conf) {
+ int selectorThreads = conf.getInt(SELECTOR_THREADS_CONF_KEY, getSelectorThreads());
+ int workerThreads = conf.getInt(WORKER_THREADS_CONF_KEY, getWorkerThreads());
+ int stopTimeoutVal = conf.getInt(STOP_TIMEOUT_CONF_KEY, getStopTimeoutVal());
+ int acceptQueueSizePerThread =
+ conf.getInt(ACCEPT_QUEUE_SIZE_PER_THREAD_CONF_KEY, getAcceptQueueSizePerThread());
+ AcceptPolicy acceptPolicy = AcceptPolicy.valueOf(
+ conf.get(ACCEPT_POLICY_CONF_KEY, getAcceptPolicy().toString()).toUpperCase(Locale.ROOT));
+
+ super.selectorThreads(selectorThreads).workerThreads(workerThreads)
+ .stopTimeoutVal(stopTimeoutVal).acceptQueueSizePerThread(acceptQueueSizePerThread)
+ .acceptPolicy(acceptPolicy);
+
+ LOG.info("Read configuration selectorThreads:" + selectorThreads + " workerThreads:"
+ + workerThreads + " stopTimeoutVal:" + stopTimeoutVal + "sec" + " acceptQueueSizePerThread:"
+ + acceptQueueSizePerThread + " acceptPolicy:" + acceptPolicy);
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HbaseHandlerMetricsProxy.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HbaseHandlerMetricsProxy.java
new file mode 100644
index 0000000..c1c312f
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HbaseHandlerMetricsProxy.java
@@ -0,0 +1,80 @@
+/*
+ * 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.thrift;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.thrift.generated.Hbase;
+import org.apache.hadoop.hbase.thrift2.generated.THBaseService;
+import org.apache.yetus.audience.InterfaceAudience;
+
+/**
+ * Converts a Hbase.Iface using InvocationHandler so that it reports process time of each call to
+ * ThriftMetrics.
+ */
+@InterfaceAudience.Private
+public final class HbaseHandlerMetricsProxy implements InvocationHandler {
+
+ private final Object handler;
+ private final ThriftMetrics metrics;
+
+ public static Hbase.Iface newInstance(Hbase.Iface handler, ThriftMetrics metrics,
+ Configuration conf) {
+ return (Hbase.Iface) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
+ new Class[] { Hbase.Iface.class }, new HbaseHandlerMetricsProxy(handler, metrics, conf));
+ }
+
+ // for thrift 2
+ public static THBaseService.Iface newInstance(THBaseService.Iface handler, ThriftMetrics metrics,
+ Configuration conf) {
+ return (THBaseService.Iface) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
+ new Class[] { THBaseService.Iface.class },
+ new HbaseHandlerMetricsProxy(handler, metrics, conf));
+ }
+
+ private HbaseHandlerMetricsProxy(Object handler, ThriftMetrics metrics, Configuration conf) {
+ this.handler = handler;
+ this.metrics = metrics;
+ }
+
+ @Override
+ public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
+ Object result;
+ long start = now();
+ try {
+ result = m.invoke(handler, args);
+ } catch (InvocationTargetException e) {
+ metrics.exception(e.getCause());
+ throw e.getTargetException();
+ } catch (Exception e) {
+ metrics.exception(e);
+ throw new RuntimeException("unexpected invocation exception: " + e.getMessage());
+ } finally {
+ long processTime = now() - start;
+ metrics.incMethodTime(m.getName(), processTime);
+ }
+ return result;
+ }
+
+ private static long now() {
+ return System.nanoTime();
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HttpAuthenticationException.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HttpAuthenticationException.java
new file mode 100644
index 0000000..a1cc718
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/HttpAuthenticationException.java
@@ -0,0 +1,47 @@
+/*
+ * 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.thrift;
+
+import org.apache.yetus.audience.InterfaceAudience;
+
+@InterfaceAudience.Private
+public class HttpAuthenticationException extends Exception {
+ private static final long serialVersionUID = 0;
+
+ /**
+ * @param cause original exception
+ */
+ public HttpAuthenticationException(Throwable cause) {
+ super(cause);
+ }
+
+ /**
+ * @param msg exception message
+ */
+ public HttpAuthenticationException(String msg) {
+ super(msg);
+ }
+
+ /**
+ * @param msg exception message
+ * @param cause original exception
+ */
+ public HttpAuthenticationException(String msg, Throwable cause) {
+ super(msg, cause);
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ImplType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ImplType.java
new file mode 100644
index 0000000..85d8e70
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ImplType.java
@@ -0,0 +1,140 @@
+/*
+ * 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.thrift;
+
+import static org.apache.hadoop.hbase.thrift.Constants.SERVER_TYPE_CONF_KEY;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.thrift.server.THsHaServer;
+import org.apache.thrift.server.TNonblockingServer;
+import org.apache.thrift.server.TServer;
+import org.apache.thrift.server.TThreadedSelectorServer;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.org.apache.commons.cli.CommandLine;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.Option;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.OptionGroup;
+
+/** An enum of server implementation selections */
+@InterfaceAudience.Private
+public enum ImplType {
+ HS_HA("hsha", true, THsHaServer.class, true),
+ NONBLOCKING("nonblocking", true, TNonblockingServer.class, true),
+ THREAD_POOL("threadpool", false, TBoundedThreadPoolServer.class, true),
+ THREADED_SELECTOR("threadedselector", true, TThreadedSelectorServer.class, true);
+
+ private static final Logger LOG = LoggerFactory.getLogger(ImplType.class);
+ public static final ImplType DEFAULT = THREAD_POOL;
+
+ final String option;
+ final boolean isAlwaysFramed;
+ final Class<? extends TServer> serverClass;
+ final boolean canSpecifyBindIP;
+
+ private ImplType(String option, boolean isAlwaysFramed, Class<? extends TServer> serverClass,
+ boolean canSpecifyBindIP) {
+ this.option = option;
+ this.isAlwaysFramed = isAlwaysFramed;
+ this.serverClass = serverClass;
+ this.canSpecifyBindIP = canSpecifyBindIP;
+ }
+
+ /**
+ * @return <code>-option</code>
+ */
+ @Override
+ public String toString() {
+ return "-" + option;
+ }
+
+ public String getOption() {
+ return option;
+ }
+
+ public boolean isAlwaysFramed() {
+ return isAlwaysFramed;
+ }
+
+ public String getDescription() {
+ StringBuilder sb = new StringBuilder("Use the " + serverClass.getSimpleName());
+ if (isAlwaysFramed) {
+ sb.append(" This implies the framed transport.");
+ }
+ if (this == DEFAULT) {
+ sb.append("This is the default.");
+ }
+ return sb.toString();
+ }
+
+ static OptionGroup createOptionGroup() {
+ OptionGroup group = new OptionGroup();
+ for (ImplType t : values()) {
+ group.addOption(new Option(t.option, t.getDescription()));
+ }
+ return group;
+ }
+
+ public static ImplType getServerImpl(Configuration conf) {
+ String confType = conf.get(SERVER_TYPE_CONF_KEY, THREAD_POOL.option);
+ for (ImplType t : values()) {
+ if (confType.equals(t.option)) {
+ return t;
+ }
+ }
+ throw new AssertionError("Unknown server ImplType.option:" + confType);
+ }
+
+ static void setServerImpl(CommandLine cmd, Configuration conf) {
+ ImplType chosenType = null;
+ int numChosen = 0;
+ for (ImplType t : values()) {
+ if (cmd.hasOption(t.option)) {
+ chosenType = t;
+ ++numChosen;
+ }
+ }
+ if (numChosen < 1) {
+ LOG.info("Using default thrift server type");
+ chosenType = DEFAULT;
+ } else if (numChosen > 1) {
+ throw new AssertionError(
+ "Exactly one option out of " + Arrays.toString(values()) + " has to be specified");
+ }
+ LOG.info("Using thrift server type " + chosenType.option);
+ conf.set(SERVER_TYPE_CONF_KEY, chosenType.option);
+ }
+
+ public String simpleClassName() {
+ return serverClass.getSimpleName();
+ }
+
+ public static List<String> serversThatCannotSpecifyBindIP() {
+ List<String> l = new ArrayList<>();
+ for (ImplType t : values()) {
+ if (!t.canSpecifyBindIP) {
+ l.add(t.simpleClassName());
+ }
+ }
+ return l;
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/IncrementCoalescer.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/IncrementCoalescer.java
new file mode 100644
index 0000000..6f48e76
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/IncrementCoalescer.java
@@ -0,0 +1,376 @@
+/*
+ * 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.thrift;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.LongAdder;
+import org.apache.hadoop.hbase.CellUtil;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.thrift.generated.TIncrement;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.hadoop.hbase.util.Threads;
+import org.apache.hadoop.metrics2.util.MBeans;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.com.google.common.util.concurrent.ThreadFactoryBuilder;
+
+/**
+ * This class will coalesce increments from a thift server if
+ * hbase.regionserver.thrift.coalesceIncrement is set to true. Turning this config to true will
+ * cause the thrift server to queue increments into an instance of this class. The thread pool
+ * associated with this class will drain the coalesced increments as the thread is able. This can
+ * cause data loss if the thrift server dies or is shut down before everything in the queue is
+ * drained.
+ */
+@InterfaceAudience.Private
+public class IncrementCoalescer implements IncrementCoalescerMBean {
+ /**
+ * Used to identify a cell that will be incremented.
+ */
+ static class FullyQualifiedRow {
+ private byte[] table;
+ private byte[] rowKey;
+ private byte[] family;
+ private byte[] qualifier;
+
+ public FullyQualifiedRow(byte[] table, byte[] rowKey, byte[] fam, byte[] qual) {
+ super();
+ this.table = table;
+ this.rowKey = rowKey;
+ this.family = fam;
+ this.qualifier = qual;
+ }
+
+ public byte[] getTable() {
+ return table;
+ }
+
+ public void setTable(byte[] table) {
+ this.table = table;
+ }
+
+ public byte[] getRowKey() {
+ return rowKey;
+ }
+
+ public byte[] getFamily() {
+ return family;
+ }
+
+ public void setFamily(byte[] fam) {
+ this.family = fam;
+ }
+
+ public byte[] getQualifier() {
+ return qualifier;
+ }
+
+ public void setQualifier(byte[] qual) {
+ this.qualifier = qual;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + Arrays.hashCode(family);
+ result = prime * result + Arrays.hashCode(qualifier);
+ result = prime * result + Arrays.hashCode(rowKey);
+ result = prime * result + Arrays.hashCode(table);
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null) {
+ return false;
+ }
+ if (getClass() != obj.getClass()) {
+ return false;
+ }
+
+ FullyQualifiedRow other = (FullyQualifiedRow) obj;
+
+ if (!Arrays.equals(family, other.family)) {
+ return false;
+ }
+ if (!Arrays.equals(qualifier, other.qualifier)) {
+ return false;
+ }
+ if (!Arrays.equals(rowKey, other.rowKey)) {
+ return false;
+ }
+
+ return Arrays.equals(table, other.table);
+ }
+ }
+
+ private final LongAdder failedIncrements = new LongAdder();
+ private final LongAdder successfulCoalescings = new LongAdder();
+ private final LongAdder totalIncrements = new LongAdder();
+ private final ConcurrentMap<FullyQualifiedRow, Long> countersMap =
+ new ConcurrentHashMap<>(100000, 0.75f, 1500);
+ private final ThreadPoolExecutor pool;
+ private final ThriftHBaseServiceHandler handler;
+
+ private int maxQueueSize = 500000;
+ private static final int CORE_POOL_SIZE = 1;
+
+ private static final Logger LOG = LoggerFactory.getLogger(IncrementCoalescer.class);
+
+ public IncrementCoalescer(ThriftHBaseServiceHandler hand) {
+ this.handler = hand;
+ LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
+ pool = new ThreadPoolExecutor(CORE_POOL_SIZE, CORE_POOL_SIZE, 50, TimeUnit.MILLISECONDS, queue,
+ new ThreadFactoryBuilder().setNameFormat("IncrementCoalescer-pool-%d").setDaemon(true)
+ .setUncaughtExceptionHandler(Threads.LOGGING_EXCEPTION_HANDLER).build());
+ MBeans.register("thrift", "Thrift", this);
+ }
+
+ public boolean queueIncrement(TIncrement inc) {
+ if (!canQueue()) {
+ failedIncrements.increment();
+ return false;
+ }
+ return internalQueueTincrement(inc);
+ }
+
+ public boolean queueIncrements(List<TIncrement> incs) {
+ if (!canQueue()) {
+ failedIncrements.increment();
+ return false;
+ }
+
+ for (TIncrement tinc : incs) {
+ internalQueueTincrement(tinc);
+ }
+
+ return true;
+ }
+
+ private boolean internalQueueTincrement(TIncrement inc) {
+ byte[][] famAndQf = CellUtil.parseColumn(inc.getColumn());
+
+ if (famAndQf.length != 2) {
+ return false;
+ }
+
+ return internalQueueIncrement(inc.getTable(), inc.getRow(), famAndQf[0], famAndQf[1],
+ inc.getAmmount());
+ }
+
+ @SuppressWarnings("FutureReturnValueIgnored")
+ private boolean internalQueueIncrement(byte[] tableName, byte[] rowKey, byte[] fam, byte[] qual,
+ long ammount) {
+ int countersMapSize = countersMap.size();
+
+ // Make sure that the number of threads is scaled.
+ dynamicallySetCoreSize(countersMapSize);
+
+ totalIncrements.increment();
+
+ FullyQualifiedRow key = new FullyQualifiedRow(tableName, rowKey, fam, qual);
+
+ long currentAmount = ammount;
+ // Spin until able to insert the value back without collisions
+ while (true) {
+ Long value = countersMap.remove(key);
+ if (value == null) {
+ // There was nothing there, create a new value
+ value = currentAmount;
+ } else {
+ value += currentAmount;
+ successfulCoalescings.increment();
+ }
+ // Try to put the value, only if there was none
+ Long oldValue = countersMap.putIfAbsent(key, value);
+ if (oldValue == null) {
+ // We were able to put it in, we're done
+ break;
+ }
+ // Someone else was able to put a value in, so let's remember our
+ // current value (plus what we picked up) and retry to add it in
+ currentAmount = value;
+ }
+
+ // We limit the size of the queue simply because all we need is a
+ // notification that something needs to be incremented. No need
+ // for millions of callables that mean the same thing.
+ if (pool.getQueue().size() <= 1000) {
+ // queue it up
+ Callable<Integer> callable = createIncCallable();
+ pool.submit(callable);
+ }
+
+ return true;
+ }
+
+ public boolean canQueue() {
+ return countersMap.size() < maxQueueSize;
+ }
+
+ private Callable<Integer> createIncCallable() {
+ return () -> {
+ int failures = 0;
+ Set<FullyQualifiedRow> keys = countersMap.keySet();
+ for (FullyQualifiedRow row : keys) {
+ Long counter = countersMap.remove(row);
+ if (counter == null) {
+ continue;
+ }
+ Table table = null;
+ try {
+ table = handler.getTable(row.getTable());
+ if (failures > 2) {
+ throw new IOException("Auto-Fail rest of ICVs");
+ }
+ table.incrementColumnValue(row.getRowKey(), row.getFamily(), row.getQualifier(), counter);
+ } catch (IOException e) {
+ // log failure of increment
+ failures++;
+ LOG.error("FAILED_ICV: " + Bytes.toString(row.getTable()) + ", "
+ + Bytes.toStringBinary(row.getRowKey()) + ", " + Bytes.toStringBinary(row.getFamily())
+ + ", " + Bytes.toStringBinary(row.getQualifier()) + ", " + counter, e);
+ } finally {
+ if (table != null) {
+ table.close();
+ }
+ }
+ }
+ return failures;
+ };
+ }
+
+ /**
+ * This method samples the incoming requests and, if selected, will check if the corePoolSize
+ * should be changed.
+ * @param countersMapSize the size of the counters map
+ */
+ private void dynamicallySetCoreSize(int countersMapSize) {
+ // Here we are using countersMapSize as a random number, meaning this
+ // could be a Random object
+ if (countersMapSize % 10 != 0) {
+ return;
+ }
+ double currentRatio = (double) countersMapSize / (double) maxQueueSize;
+ int newValue;
+
+ if (currentRatio < 0.1) {
+ newValue = 1;
+ } else if (currentRatio < 0.3) {
+ newValue = 2;
+ } else if (currentRatio < 0.5) {
+ newValue = 4;
+ } else if (currentRatio < 0.7) {
+ newValue = 8;
+ } else if (currentRatio < 0.9) {
+ newValue = 14;
+ } else {
+ newValue = 22;
+ }
+
+ if (pool.getCorePoolSize() != newValue) {
+ pool.setCorePoolSize(newValue);
+ }
+ }
+
+ // MBean get/set methods
+ @Override
+ public int getQueueSize() {
+ return pool.getQueue().size();
+ }
+
+ @Override
+ public int getMaxQueueSize() {
+ return this.maxQueueSize;
+ }
+
+ @Override
+ public void setMaxQueueSize(int newSize) {
+ this.maxQueueSize = newSize;
+ }
+
+ @Override
+ public long getPoolCompletedTaskCount() {
+ return pool.getCompletedTaskCount();
+ }
+
+ @Override
+ public long getPoolTaskCount() {
+ return pool.getTaskCount();
+ }
+
+ @Override
+ public int getPoolLargestPoolSize() {
+ return pool.getLargestPoolSize();
+ }
+
+ @Override
+ public int getCorePoolSize() {
+ return pool.getCorePoolSize();
+ }
+
+ @Override
+ public void setCorePoolSize(int newCoreSize) {
+ pool.setCorePoolSize(newCoreSize);
+ }
+
+ @Override
+ public int getMaxPoolSize() {
+ return pool.getMaximumPoolSize();
+ }
+
+ @Override
+ public void setMaxPoolSize(int newMaxSize) {
+ pool.setMaximumPoolSize(newMaxSize);
+ }
+
+ @Override
+ public long getFailedIncrements() {
+ return failedIncrements.sum();
+ }
+
+ @Override
+ public long getSuccessfulCoalescings() {
+ return successfulCoalescings.sum();
+ }
+
+ @Override
+ public long getTotalIncrements() {
+ return totalIncrements.sum();
+ }
+
+ @Override
+ public long getCountersMapSize() {
+ return countersMap.size();
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/IncrementCoalescerMBean.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/IncrementCoalescerMBean.java
new file mode 100644
index 0000000..e7e528c
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/IncrementCoalescerMBean.java
@@ -0,0 +1,51 @@
+/*
+ * 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.thrift;
+
+import org.apache.yetus.audience.InterfaceAudience;
+
+@InterfaceAudience.Private
+public interface IncrementCoalescerMBean {
+ int getQueueSize();
+
+ int getMaxQueueSize();
+
+ void setMaxQueueSize(int newSize);
+
+ long getPoolCompletedTaskCount();
+
+ long getPoolTaskCount();
+
+ int getPoolLargestPoolSize();
+
+ int getCorePoolSize();
+
+ void setCorePoolSize(int newCoreSize);
+
+ int getMaxPoolSize();
+
+ void setMaxPoolSize(int newMaxSize);
+
+ long getFailedIncrements();
+
+ long getSuccessfulCoalescings();
+
+ long getTotalIncrements();
+
+ long getCountersMapSize();
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/TBoundedThreadPoolServer.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/TBoundedThreadPoolServer.java
new file mode 100644
index 0000000..8da9173
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/TBoundedThreadPoolServer.java
@@ -0,0 +1,299 @@
+/*
+ * 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.thrift;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
+import org.apache.hadoop.hbase.util.Threads;
+import org.apache.thrift.TException;
+import org.apache.thrift.TProcessor;
+import org.apache.thrift.protocol.TProtocol;
+import org.apache.thrift.server.TServer;
+import org.apache.thrift.server.TThreadPoolServer;
+import org.apache.thrift.transport.TServerTransport;
+import org.apache.thrift.transport.TSocket;
+import org.apache.thrift.transport.TTransport;
+import org.apache.thrift.transport.TTransportException;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.com.google.common.util.concurrent.ThreadFactoryBuilder;
+
+/**
+ * A bounded thread pool server customized for HBase.
+ */
+@InterfaceAudience.Private
+public class TBoundedThreadPoolServer extends TServer {
+
+ private static final String QUEUE_FULL_MSG = "Queue is full, closing connection";
+
+ /**
+ * The "core size" of the thread pool. New threads are created on every connection until this many
+ * threads are created.
+ */
+ public static final String MIN_WORKER_THREADS_CONF_KEY = "hbase.thrift.minWorkerThreads";
+
+ /**
+ * This default core pool size should be enough for many test scenarios. We want to override this
+ * with a much larger number (e.g. at least 200) for a large-scale production setup.
+ */
+ public static final int DEFAULT_MIN_WORKER_THREADS = 16;
+
+ /**
+ * The maximum size of the thread pool. When the pending request queue overflows, new threads are
+ * created until their number reaches this number. After that, the server starts dropping
+ * connections.
+ */
+ public static final String MAX_WORKER_THREADS_CONF_KEY = "hbase.thrift.maxWorkerThreads";
+
+ public static final int DEFAULT_MAX_WORKER_THREADS = 1000;
+
+ /**
+ * The maximum number of pending connections waiting in the queue. If there are no idle threads in
+ * the pool, the server queues requests. Only when the queue overflows, new threads are added, up
+ * to hbase.thrift.maxQueuedRequests threads.
+ */
+ public static final String MAX_QUEUED_REQUESTS_CONF_KEY = "hbase.thrift.maxQueuedRequests";
+
+ public static final int DEFAULT_MAX_QUEUED_REQUESTS = 1000;
+
+ /**
+ * Default amount of time in seconds to keep a thread alive. Worker threads are stopped after
+ * being idle for this long.
+ */
+ public static final String THREAD_KEEP_ALIVE_TIME_SEC_CONF_KEY =
+ "hbase.thrift.threadKeepAliveTimeSec";
+
+ private static final int DEFAULT_THREAD_KEEP_ALIVE_TIME_SEC = 60;
+
+ /**
+ * Time to wait after interrupting all worker threads. This is after a clean shutdown has been
+ * attempted.
+ */
+ public static final int TIME_TO_WAIT_AFTER_SHUTDOWN_MS = 5000;
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(TBoundedThreadPoolServer.class.getName());
+
+ private final CallQueue callQueue;
+
+ public static class Args extends TThreadPoolServer.Args {
+ int maxQueuedRequests;
+ int threadKeepAliveTimeSec;
+
+ public Args(TServerTransport transport, Configuration conf) {
+ super(transport);
+ minWorkerThreads = conf.getInt(MIN_WORKER_THREADS_CONF_KEY, DEFAULT_MIN_WORKER_THREADS);
+ maxWorkerThreads = conf.getInt(MAX_WORKER_THREADS_CONF_KEY, DEFAULT_MAX_WORKER_THREADS);
+ maxQueuedRequests = conf.getInt(MAX_QUEUED_REQUESTS_CONF_KEY, DEFAULT_MAX_QUEUED_REQUESTS);
+ threadKeepAliveTimeSec =
+ conf.getInt(THREAD_KEEP_ALIVE_TIME_SEC_CONF_KEY, DEFAULT_THREAD_KEEP_ALIVE_TIME_SEC);
+ }
+
+ @Override
+ public String toString() {
+ return "min worker threads=" + minWorkerThreads + ", max worker threads=" + maxWorkerThreads
+ + ", max queued requests=" + maxQueuedRequests;
+ }
+ }
+
+ /** Executor service for handling client connections */
+ private ThreadPoolExecutor executorService;
+
+ /** Flag for stopping the server */
+ private volatile boolean stopped;
+
+ private Args serverOptions;
+
+ public TBoundedThreadPoolServer(Args options, ThriftMetrics metrics) {
+ super(options);
+
+ int minWorkerThreads = options.minWorkerThreads;
+ int maxWorkerThreads = options.maxWorkerThreads;
+ if (options.maxQueuedRequests > 0) {
+ this.callQueue = new CallQueue(new LinkedBlockingQueue<>(options.maxQueuedRequests), metrics);
+ minWorkerThreads = maxWorkerThreads;
+ } else {
+ this.callQueue = new CallQueue(new SynchronousQueue<>(), metrics);
+ }
+
+ ThreadFactoryBuilder tfb = new ThreadFactoryBuilder();
+ tfb.setDaemon(true);
+ tfb.setNameFormat("thrift-worker-%d");
+ executorService = new THBaseThreadPoolExecutor(minWorkerThreads, maxWorkerThreads,
+ options.threadKeepAliveTimeSec, TimeUnit.SECONDS, this.callQueue, tfb.build(), metrics);
+ executorService.allowCoreThreadTimeOut(true);
+ serverOptions = options;
+ }
+
+ @Override
+ public void serve() {
+ try {
+ serverTransport_.listen();
+ } catch (TTransportException ttx) {
+ LOG.error("Error occurred during listening.", ttx);
+ return;
+ }
+
+ Runtime.getRuntime().addShutdownHook(new Thread(getClass().getSimpleName() + "-shutdown-hook") {
+ @Override
+ public void run() {
+ TBoundedThreadPoolServer.this.stop();
+ }
+ });
+
+ stopped = false;
+ while (!stopped && !Thread.interrupted()) {
+ TTransport client = null;
+ try {
+ client = serverTransport_.accept();
+ } catch (TTransportException ttx) {
+ if (!stopped) {
+ LOG.warn("Transport error when accepting message", ttx);
+ continue;
+ } else {
+ // The server has been stopped
+ break;
+ }
+ }
+
+ ClientConnnection command = new ClientConnnection(client);
+ try {
+ executorService.execute(command);
+ } catch (RejectedExecutionException rex) {
+ if (client.getClass() == TSocket.class) {
+ // We expect the client to be TSocket.
+ LOG.warn(
+ QUEUE_FULL_MSG + " from " + ((TSocket) client).getSocket().getRemoteSocketAddress());
+ } else {
+ LOG.warn(QUEUE_FULL_MSG, rex);
+ }
+ client.close();
+ }
+ }
+
+ shutdownServer();
+ }
+
+ /**
+ * Loop until {@link ExecutorService#awaitTermination} finally does return without an interrupted
+ * exception. If we don't do this, then we'll shut down prematurely. We want to let the executor
+ * service clear its task queue, closing client sockets appropriately.
+ */
+ private void shutdownServer() {
+ executorService.shutdown();
+
+ long msLeftToWait = serverOptions.stopTimeoutUnit.toMillis(serverOptions.stopTimeoutVal);
+ long timeMillis = EnvironmentEdgeManager.currentTime();
+
+ LOG
+ .info("Waiting for up to " + msLeftToWait + " ms to finish processing" + " pending requests");
+ boolean interrupted = false;
+ while (msLeftToWait >= 0) {
+ try {
+ executorService.awaitTermination(msLeftToWait, TimeUnit.MILLISECONDS);
+ break;
+ } catch (InterruptedException ix) {
+ long timePassed = EnvironmentEdgeManager.currentTime() - timeMillis;
+ msLeftToWait -= timePassed;
+ timeMillis += timePassed;
+ interrupted = true;
+ }
+ }
+
+ LOG.info("Interrupting all worker threads and waiting for " + TIME_TO_WAIT_AFTER_SHUTDOWN_MS
+ + " ms longer");
+
+ // This will interrupt all the threads, even those running a task.
+ executorService.shutdownNow();
+ Threads.sleepWithoutInterrupt(TIME_TO_WAIT_AFTER_SHUTDOWN_MS);
+
+ // Preserve the interrupted status.
+ if (interrupted) {
+ Thread.currentThread().interrupt();
+ }
+ LOG.info("Thrift server shutdown complete");
+ }
+
+ @Override
+ public void stop() {
+ stopped = true;
+ serverTransport_.interrupt();
+ }
+
+ private final class ClientConnnection implements Runnable {
+
+ private TTransport client;
+
+ /**
+ * Default constructor.
+ * @param client Transport to process
+ */
+ private ClientConnnection(TTransport client) {
+ this.client = client;
+ }
+
+ /**
+ * Loops on processing a client forever
+ */
+ @Override
+ public void run() {
+ TProcessor processor = null;
+ TTransport inputTransport = null;
+ TTransport outputTransport = null;
+ TProtocol inputProtocol = null;
+ TProtocol outputProtocol = null;
+ try {
+ processor = processorFactory_.getProcessor(client);
+ inputTransport = inputTransportFactory_.getTransport(client);
+ outputTransport = outputTransportFactory_.getTransport(client);
+ inputProtocol = inputProtocolFactory_.getProtocol(inputTransport);
+ outputProtocol = outputProtocolFactory_.getProtocol(outputTransport);
+ // we check stopped_ first to make sure we're not supposed to be shutting
+ // down. this is necessary for graceful shutdown.
+ while (true) {
+ if (stopped) {
+ break;
+ }
+ processor.process(inputProtocol, outputProtocol);
+ }
+ } catch (TTransportException ttx) {
+ // Assume the client died and continue silently
+ } catch (TException tx) {
+ LOG.error("Thrift error occurred during processing of message.", tx);
+ } catch (Exception x) {
+ LOG.error("Error occurred during processing of message.", x);
+ }
+
+ if (inputTransport != null) {
+ inputTransport.close();
+ }
+
+ if (outputTransport != null) {
+ outputTransport.close();
+ }
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/THBaseThreadPoolExecutor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/THBaseThreadPoolExecutor.java
new file mode 100644
index 0000000..a3562c7
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/THBaseThreadPoolExecutor.java
@@ -0,0 +1,62 @@
+/*
+ * 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.thrift;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import org.apache.yetus.audience.InterfaceAudience;
+
+/**
+ * A ThreadPoolExecutor customized for working with HBase thrift to update metrics before and after
+ * the execution of a task.
+ */
+
+@InterfaceAudience.Private
+public class THBaseThreadPoolExecutor extends ThreadPoolExecutor {
+
+ private ThriftMetrics metrics;
+
+ public THBaseThreadPoolExecutor(int corePoolSize, int maxPoolSize, long keepAliveTime,
+ TimeUnit unit, BlockingQueue<Runnable> workQueue, ThriftMetrics metrics) {
+ this(corePoolSize, maxPoolSize, keepAliveTime, unit, workQueue, null, metrics);
+ }
+
+ public THBaseThreadPoolExecutor(int corePoolSize, int maxPoolSize, long keepAliveTime,
+ TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
+ ThriftMetrics metrics) {
+ super(corePoolSize, maxPoolSize, keepAliveTime, unit, workQueue);
+ if (threadFactory != null) {
+ setThreadFactory(threadFactory);
+ }
+ this.metrics = metrics;
+ }
+
+ @Override
+ protected void beforeExecute(Thread t, Runnable r) {
+ super.beforeExecute(t, r);
+ metrics.incActiveWorkerCount();
+ }
+
+ @Override
+ protected void afterExecute(Runnable r, Throwable t) {
+ metrics.decActiveWorkerCount();
+ super.afterExecute(r, t);
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHBaseServiceHandler.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHBaseServiceHandler.java
new file mode 100644
index 0000000..d7085c6
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHBaseServiceHandler.java
@@ -0,0 +1,1346 @@
+/*
+ * 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.thrift;
+
+import static org.apache.hadoop.hbase.HConstants.DEFAULT_HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD;
+import static org.apache.hadoop.hbase.HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD;
+import static org.apache.hadoop.hbase.thrift.Constants.COALESCE_INC_KEY;
+import static org.apache.hadoop.hbase.util.Bytes.getBytes;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.concurrent.TimeUnit;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.CatalogFamilyFormat;
+import org.apache.hadoop.hbase.Cell;
+import org.apache.hadoop.hbase.CellBuilder;
+import org.apache.hadoop.hbase.CellBuilderFactory;
+import org.apache.hadoop.hbase.CellBuilderType;
+import org.apache.hadoop.hbase.CellUtil;
+import org.apache.hadoop.hbase.DoNotRetryIOException;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.HRegionLocation;
+import org.apache.hadoop.hbase.KeyValue;
+import org.apache.hadoop.hbase.ServerName;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.TableNotFoundException;
+import org.apache.hadoop.hbase.client.Append;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.client.Delete;
+import org.apache.hadoop.hbase.client.Durability;
+import org.apache.hadoop.hbase.client.Get;
+import org.apache.hadoop.hbase.client.Increment;
+import org.apache.hadoop.hbase.client.OperationWithAttributes;
+import org.apache.hadoop.hbase.client.Put;
+import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.RegionLocator;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.client.ResultScanner;
+import org.apache.hadoop.hbase.client.Scan;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
+import org.apache.hadoop.hbase.filter.Filter;
+import org.apache.hadoop.hbase.filter.ParseFilter;
+import org.apache.hadoop.hbase.filter.PrefixFilter;
+import org.apache.hadoop.hbase.filter.WhileMatchFilter;
+import org.apache.hadoop.hbase.security.UserProvider;
+import org.apache.hadoop.hbase.security.access.AccessControlClient;
+import org.apache.hadoop.hbase.security.access.Permission;
+import org.apache.hadoop.hbase.thrift.generated.AlreadyExists;
+import org.apache.hadoop.hbase.thrift.generated.BatchMutation;
+import org.apache.hadoop.hbase.thrift.generated.ColumnDescriptor;
+import org.apache.hadoop.hbase.thrift.generated.Hbase;
+import org.apache.hadoop.hbase.thrift.generated.IOError;
+import org.apache.hadoop.hbase.thrift.generated.IllegalArgument;
+import org.apache.hadoop.hbase.thrift.generated.Mutation;
+import org.apache.hadoop.hbase.thrift.generated.TAccessControlEntity;
+import org.apache.hadoop.hbase.thrift.generated.TAppend;
+import org.apache.hadoop.hbase.thrift.generated.TCell;
+import org.apache.hadoop.hbase.thrift.generated.TIncrement;
+import org.apache.hadoop.hbase.thrift.generated.TPermissionScope;
+import org.apache.hadoop.hbase.thrift.generated.TRegionInfo;
+import org.apache.hadoop.hbase.thrift.generated.TRowResult;
+import org.apache.hadoop.hbase.thrift.generated.TScan;
+import org.apache.hadoop.hbase.thrift.generated.TThriftServerType;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.thrift.TException;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.com.google.common.base.Throwables;
+import org.apache.hbase.thirdparty.com.google.common.cache.Cache;
+import org.apache.hbase.thirdparty.com.google.common.cache.CacheBuilder;
+
+/**
+ * The HBaseServiceHandler is a glue object that connects Thrift RPC calls to the HBase client API
+ * primarily defined in the Admin and Table objects.
+ */
+@InterfaceAudience.Private
+@SuppressWarnings("deprecation")
+public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements Hbase.Iface {
+ private static final Logger LOG = LoggerFactory.getLogger(ThriftHBaseServiceHandler.class);
+
+ public static final int HREGION_VERSION = 1;
+
+ // nextScannerId and scannerMap are used to manage scanner state
+ private int nextScannerId = 0;
+ private Cache<Integer, ResultScannerWrapper> scannerMap;
+ IncrementCoalescer coalescer;
+
+ /**
+ * Returns a list of all the column families for a given Table.
+ */
+ byte[][] getAllColumns(Table table) throws IOException {
+ ColumnFamilyDescriptor[] cds = table.getDescriptor().getColumnFamilies();
+ byte[][] columns = new byte[cds.length][];
+ for (int i = 0; i < cds.length; i++) {
+ columns[i] = Bytes.add(cds[i].getName(), KeyValue.COLUMN_FAMILY_DELIM_ARRAY);
+ }
+ return columns;
+ }
+
+ /**
+ * Assigns a unique ID to the scanner and adds the mapping to an internal hash-map.
+ * @param scanner the {@link ResultScanner} to add
+ * @return integer scanner id
+ */
+ protected synchronized int addScanner(ResultScanner scanner, boolean sortColumns) {
+ int id = nextScannerId++;
+ ResultScannerWrapper resultScannerWrapper = new ResultScannerWrapper(scanner, sortColumns);
+ scannerMap.put(id, resultScannerWrapper);
+ return id;
+ }
+
+ /**
+ * Returns the scanner associated with the specified ID.
+ * @param id the ID of the scanner to get
+ * @return a Scanner, or null if ID was invalid.
+ */
+ private synchronized ResultScannerWrapper getScanner(int id) {
+ return scannerMap.getIfPresent(id);
+ }
+
+ /**
+ * Removes the scanner associated with the specified ID from the internal id->scanner hash-map.
+ * @param id the ID of the scanner to remove
+ */
+ private synchronized void removeScanner(int id) {
+ scannerMap.invalidate(id);
+ }
+
+ protected ThriftHBaseServiceHandler(final Configuration c, final UserProvider userProvider)
+ throws IOException {
+ super(c, userProvider);
+ long cacheTimeout =
+ c.getLong(HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD, DEFAULT_HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD)
+ * 2;
+
+ scannerMap =
+ CacheBuilder.newBuilder().expireAfterAccess(cacheTimeout, TimeUnit.MILLISECONDS).build();
+
+ this.coalescer = new IncrementCoalescer(this);
+ }
+
+ @Override
+ public void enableTable(ByteBuffer tableName) throws IOError {
+ try {
+ getAdmin().enableTable(getTableName(tableName));
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ @Override
+ public void disableTable(ByteBuffer tableName) throws IOError {
+ try {
+ getAdmin().disableTable(getTableName(tableName));
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ @Override
+ public boolean isTableEnabled(ByteBuffer tableName) throws IOError {
+ try {
+ return this.connectionCache.getAdmin().isTableEnabled(getTableName(tableName));
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ @Override
+ public Map<ByteBuffer, Boolean> getTableNamesWithIsTableEnabled() throws IOError {
+ try {
+ HashMap<ByteBuffer, Boolean> tables = new HashMap<>();
+ for (ByteBuffer tableName : this.getTableNames()) {
+ tables.put(tableName, this.isTableEnabled(tableName));
+ }
+ return tables;
+ } catch (IOError e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ // ThriftServerRunner.compact should be deprecated and replaced with methods specific to
+ // table and region.
+ @Override
+ public void compact(ByteBuffer tableNameOrRegionName) throws IOError {
+ try {
+ try {
+ getAdmin().compactRegion(getBytes(tableNameOrRegionName));
+ } catch (IllegalArgumentException e) {
+ // Invalid region, try table
+ getAdmin().compact(TableName.valueOf(getBytes(tableNameOrRegionName)));
+ }
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ // ThriftServerRunner.majorCompact should be deprecated and replaced with methods specific
+ // to table and region.
+ @Override
+ public void majorCompact(ByteBuffer tableNameOrRegionName) throws IOError {
+ try {
+ try {
+ getAdmin().compactRegion(getBytes(tableNameOrRegionName));
+ } catch (IllegalArgumentException e) {
+ // Invalid region, try table
+ getAdmin().compact(TableName.valueOf(getBytes(tableNameOrRegionName)));
+ }
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ @Override
+ public List<ByteBuffer> getTableNames() throws IOError {
+ try {
+ TableName[] tableNames = this.getAdmin().listTableNames();
+ ArrayList<ByteBuffer> list = new ArrayList<>(tableNames.length);
+ for (TableName tableName : tableNames) {
+ list.add(ByteBuffer.wrap(tableName.getName()));
+ }
+ return list;
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ /**
+ * @return the list of regions in the given table, or an empty list if the table does not exist
+ */
+ @Override
+ public List<TRegionInfo> getTableRegions(ByteBuffer tableName) throws IOError {
+ try (RegionLocator locator = connectionCache.getRegionLocator(getBytes(tableName))) {
+ List<HRegionLocation> regionLocations = locator.getAllRegionLocations();
+ List<TRegionInfo> results = new ArrayList<>(regionLocations.size());
+ for (HRegionLocation regionLocation : regionLocations) {
+ RegionInfo info = regionLocation.getRegion();
+ ServerName serverName = regionLocation.getServerName();
+ TRegionInfo region = new TRegionInfo();
+ region.serverName = ByteBuffer.wrap(Bytes.toBytes(serverName.getHostname()));
+ region.port = serverName.getPort();
+ region.startKey = ByteBuffer.wrap(info.getStartKey());
+ region.endKey = ByteBuffer.wrap(info.getEndKey());
+ region.id = info.getRegionId();
+ region.name = ByteBuffer.wrap(info.getRegionName());
+ region.version = HREGION_VERSION; // HRegion now not versioned, PB encoding used
+ results.add(region);
+ }
+ return results;
+ } catch (TableNotFoundException e) {
+ // Return empty list for non-existing table
+ return Collections.emptyList();
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ @Override
+ public List<TCell> get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ if (famAndQf.length == 1) {
+ return get(tableName, row, famAndQf[0], null, attributes);
+ }
+ if (famAndQf.length == 2) {
+ return get(tableName, row, famAndQf[0], famAndQf[1], attributes);
+ }
+ throw new IllegalArgumentException("Invalid familyAndQualifier provided.");
+ }
+
+ /**
+ * Note: this internal interface is slightly different from public APIs in regard to handling of
+ * the qualifier. Here we differ from the public Java API in that null != byte[0]. Rather, we
+ * respect qual == null as a request for the entire column family. The caller (
+ * {@link #get(ByteBuffer, ByteBuffer, ByteBuffer, Map)}) interface IS consistent in that the
+ * column is parse like normal.
+ */
+ protected List<TCell> get(ByteBuffer tableName, ByteBuffer row, byte[] family, byte[] qualifier,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Get get = new Get(getBytes(row));
+ addAttributes(get, attributes);
+ if (qualifier == null) {
+ get.addFamily(family);
+ } else {
+ get.addColumn(family, qualifier);
+ }
+ Result result = table.get(get);
+ return ThriftUtilities.cellFromHBase(result.rawCells());
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public List<TCell> getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column,
+ int numVersions, Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ if (famAndQf.length == 1) {
+ return getVer(tableName, row, famAndQf[0], null, numVersions, attributes);
+ }
+ if (famAndQf.length == 2) {
+ return getVer(tableName, row, famAndQf[0], famAndQf[1], numVersions, attributes);
+ }
+ throw new IllegalArgumentException("Invalid familyAndQualifier provided.");
+
+ }
+
+ /**
+ * Note: this public interface is slightly different from public Java APIs in regard to handling
+ * of the qualifier. Here we differ from the public Java API in that null != byte[0]. Rather, we
+ * respect qual == null as a request for the entire column family. If you want to access the
+ * entire column family, use {@link #getVer(ByteBuffer, ByteBuffer, ByteBuffer, int, Map)} with a
+ * {@code column} value that lacks a {@code ':'}.
+ */
+ public List<TCell> getVer(ByteBuffer tableName, ByteBuffer row, byte[] family, byte[] qualifier,
+ int numVersions, Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Get get = new Get(getBytes(row));
+ addAttributes(get, attributes);
+ if (null == qualifier) {
+ get.addFamily(family);
+ } else {
+ get.addColumn(family, qualifier);
+ }
+ get.readVersions(numVersions);
+ Result result = table.get(get);
+ return ThriftUtilities.cellFromHBase(result.rawCells());
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public List<TCell> getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column,
+ long timestamp, int numVersions, Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ if (famAndQf.length == 1) {
+ return getVerTs(tableName, row, famAndQf[0], null, timestamp, numVersions, attributes);
+ }
+ if (famAndQf.length == 2) {
+ return getVerTs(tableName, row, famAndQf[0], famAndQf[1], timestamp, numVersions, attributes);
+ }
+ throw new IllegalArgumentException("Invalid familyAndQualifier provided.");
+ }
+
+ /**
+ * Note: this internal interface is slightly different from public APIs in regard to handling of
+ * the qualifier. Here we differ from the public Java API in that null != byte[0]. Rather, we
+ * respect qual == null as a request for the entire column family. The caller (
+ * {@link #getVerTs(ByteBuffer, ByteBuffer, ByteBuffer, long, int, Map)}) interface IS consistent
+ * in that the column is parse like normal.
+ */
+ protected List<TCell> getVerTs(ByteBuffer tableName, ByteBuffer row, byte[] family,
+ byte[] qualifier, long timestamp, int numVersions, Map<ByteBuffer, ByteBuffer> attributes)
+ throws IOError {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Get get = new Get(getBytes(row));
+ addAttributes(get, attributes);
+ if (null == qualifier) {
+ get.addFamily(family);
+ } else {
+ get.addColumn(family, qualifier);
+ }
+ get.setTimeRange(0, timestamp);
+ get.readVersions(numVersions);
+ Result result = table.get(get);
+ return ThriftUtilities.cellFromHBase(result.rawCells());
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public List<TRowResult> getRow(ByteBuffer tableName, ByteBuffer row,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ return getRowWithColumnsTs(tableName, row, null, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public List<TRowResult> getRowWithColumns(ByteBuffer tableName, ByteBuffer row,
+ List<ByteBuffer> columns, Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ return getRowWithColumnsTs(tableName, row, columns, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public List<TRowResult> getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ return getRowWithColumnsTs(tableName, row, null, timestamp, attributes);
+ }
+
+ @Override
+ public List<TRowResult> getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row,
+ List<ByteBuffer> columns, long timestamp, Map<ByteBuffer, ByteBuffer> attributes)
+ throws IOError {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ if (columns == null) {
+ Get get = new Get(getBytes(row));
+ addAttributes(get, attributes);
+ get.setTimeRange(0, timestamp);
+ Result result = table.get(get);
+ return ThriftUtilities.rowResultFromHBase(result);
+ }
+ Get get = new Get(getBytes(row));
+ addAttributes(get, attributes);
+ for (ByteBuffer column : columns) {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ if (famAndQf.length == 1) {
+ get.addFamily(famAndQf[0]);
+ } else {
+ get.addColumn(famAndQf[0], famAndQf[1]);
+ }
+ }
+ get.setTimeRange(0, timestamp);
+ Result result = table.get(get);
+ return ThriftUtilities.rowResultFromHBase(result);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public List<TRowResult> getRows(ByteBuffer tableName, List<ByteBuffer> rows,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ return getRowsWithColumnsTs(tableName, rows, null, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public List<TRowResult> getRowsWithColumns(ByteBuffer tableName, List<ByteBuffer> rows,
+ List<ByteBuffer> columns, Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ return getRowsWithColumnsTs(tableName, rows, columns, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public List<TRowResult> getRowsTs(ByteBuffer tableName, List<ByteBuffer> rows, long timestamp,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ return getRowsWithColumnsTs(tableName, rows, null, timestamp, attributes);
+ }
+
+ @Override
+ public List<TRowResult> getRowsWithColumnsTs(ByteBuffer tableName, List<ByteBuffer> rows,
+ List<ByteBuffer> columns, long timestamp, Map<ByteBuffer, ByteBuffer> attributes)
+ throws IOError {
+
+ Table table = null;
+ try {
+ List<Get> gets = new ArrayList<>(rows.size());
+ table = getTable(tableName);
+ if (metrics != null) {
+ metrics.incNumRowKeysInBatchGet(rows.size());
+ }
+ for (ByteBuffer row : rows) {
+ Get get = new Get(getBytes(row));
+ addAttributes(get, attributes);
+ if (columns != null) {
+
+ for (ByteBuffer column : columns) {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ if (famAndQf.length == 1) {
+ get.addFamily(famAndQf[0]);
+ } else {
+ get.addColumn(famAndQf[0], famAndQf[1]);
+ }
+ }
+ }
+ get.setTimeRange(0, timestamp);
+ gets.add(get);
+ }
+ Result[] result = table.get(gets);
+ return ThriftUtilities.rowResultFromHBase(result);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ deleteAllTs(tableName, row, column, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Delete delete = new Delete(getBytes(row));
+ addAttributes(delete, attributes);
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ if (famAndQf.length == 1) {
+ delete.addFamily(famAndQf[0], timestamp);
+ } else {
+ delete.addColumns(famAndQf[0], famAndQf[1], timestamp);
+ }
+ table.delete(delete);
+
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public void deleteAllRow(ByteBuffer tableName, ByteBuffer row,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ deleteAllRowTs(tableName, row, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Delete delete = new Delete(getBytes(row), timestamp);
+ addAttributes(delete, attributes);
+ table.delete(delete);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public void createTable(ByteBuffer in_tableName, List<ColumnDescriptor> columnFamilies)
+ throws IOError, IllegalArgument, AlreadyExists {
+ TableName tableName = getTableName(in_tableName);
+ try {
+ if (getAdmin().tableExists(tableName)) {
+ throw new AlreadyExists("table name already in use");
+ }
+ TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName);
+ for (ColumnDescriptor col : columnFamilies) {
+ builder.setColumnFamily(ThriftUtilities.colDescFromThrift(col));
+ }
+ getAdmin().createTable(builder.build());
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } catch (IllegalArgumentException e) {
+ LOG.warn(e.getMessage(), e);
+ throw new IllegalArgument(Throwables.getStackTraceAsString(e));
+ }
+ }
+
+ private static TableName getTableName(ByteBuffer buffer) {
+ return TableName.valueOf(getBytes(buffer));
+ }
+
+ @Override
+ public void deleteTable(ByteBuffer in_tableName) throws IOError {
+ TableName tableName = getTableName(in_tableName);
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("deleteTable: table={}", tableName);
+ }
+ try {
+ if (!getAdmin().tableExists(tableName)) {
+ throw new IOException("table does not exist");
+ }
+ getAdmin().deleteTable(tableName);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ @Override
+ public void mutateRow(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError, IllegalArgument {
+ mutateRowTs(tableName, row, mutations, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations,
+ long timestamp, Map<ByteBuffer, ByteBuffer> attributes) throws IOError, IllegalArgument {
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Put put = new Put(getBytes(row), timestamp);
+ addAttributes(put, attributes);
+
+ Delete delete = new Delete(getBytes(row));
+ addAttributes(delete, attributes);
+ if (metrics != null) {
+ metrics.incNumRowKeysInBatchMutate(mutations.size());
+ }
+
+ // I apologize for all this mess :)
+ CellBuilder builder = CellBuilderFactory.create(CellBuilderType.SHALLOW_COPY);
+ for (Mutation m : mutations) {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(m.column));
+ if (m.isDelete) {
+ if (famAndQf.length == 1) {
+ delete.addFamily(famAndQf[0], timestamp);
+ } else {
+ delete.addColumns(famAndQf[0], famAndQf[1], timestamp);
+ }
+ delete.setDurability(m.writeToWAL ? Durability.SYNC_WAL : Durability.SKIP_WAL);
+ } else {
+ if (famAndQf.length == 1) {
+ LOG.warn("No column qualifier specified. Delete is the only mutation supported "
+ + "over the whole column family.");
+ } else {
+ put.add(builder.clear().setRow(put.getRow()).setFamily(famAndQf[0])
+ .setQualifier(famAndQf[1]).setTimestamp(put.getTimestamp()).setType(Cell.Type.Put)
+ .setValue(m.value != null ? getBytes(m.value) : HConstants.EMPTY_BYTE_ARRAY).build());
+ }
+ put.setDurability(m.writeToWAL ? Durability.SYNC_WAL : Durability.SKIP_WAL);
+ }
+ }
+ if (!delete.isEmpty()) {
+ table.delete(delete);
+ }
+ if (!put.isEmpty()) {
+ table.put(put);
+ }
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } catch (IllegalArgumentException e) {
+ LOG.warn(e.getMessage(), e);
+ throw new IllegalArgument(Throwables.getStackTraceAsString(e));
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public void mutateRows(ByteBuffer tableName, List<BatchMutation> rowBatches,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError, IllegalArgument, TException {
+ mutateRowsTs(tableName, rowBatches, HConstants.LATEST_TIMESTAMP, attributes);
+ }
+
+ @Override
+ public void mutateRowsTs(ByteBuffer tableName, List<BatchMutation> rowBatches, long timestamp,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError, IllegalArgument, TException {
+ List<Put> puts = new ArrayList<>();
+ List<Delete> deletes = new ArrayList<>();
+ CellBuilder builder = CellBuilderFactory.create(CellBuilderType.SHALLOW_COPY);
+ for (BatchMutation batch : rowBatches) {
+ byte[] row = getBytes(batch.row);
+ List<Mutation> mutations = batch.mutations;
+ Delete delete = new Delete(row);
+ addAttributes(delete, attributes);
+ Put put = new Put(row, timestamp);
+ addAttributes(put, attributes);
+ for (Mutation m : mutations) {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(m.column));
+ if (m.isDelete) {
+ // no qualifier, family only.
+ if (famAndQf.length == 1) {
+ delete.addFamily(famAndQf[0], timestamp);
+ } else {
+ delete.addColumns(famAndQf[0], famAndQf[1], timestamp);
+ }
+ delete.setDurability(m.writeToWAL ? Durability.SYNC_WAL : Durability.SKIP_WAL);
+ } else {
+ if (famAndQf.length == 1) {
+ LOG.warn("No column qualifier specified. Delete is the only mutation supported "
+ + "over the whole column family.");
+ }
+ if (famAndQf.length == 2) {
+ try {
+ put.add(builder.clear().setRow(put.getRow()).setFamily(famAndQf[0])
+ .setQualifier(famAndQf[1]).setTimestamp(put.getTimestamp()).setType(Cell.Type.Put)
+ .setValue(m.value != null ? getBytes(m.value) : HConstants.EMPTY_BYTE_ARRAY)
+ .build());
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e);
+ }
+ } else {
+ throw new IllegalArgumentException("Invalid famAndQf provided.");
+ }
+ put.setDurability(m.writeToWAL ? Durability.SYNC_WAL : Durability.SKIP_WAL);
+ }
+ }
+ if (!delete.isEmpty()) {
+ deletes.add(delete);
+ }
+ if (!put.isEmpty()) {
+ puts.add(put);
+ }
+ }
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ if (!puts.isEmpty()) {
+ table.put(puts);
+ }
+ if (!deletes.isEmpty()) {
+ table.delete(deletes);
+ }
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } catch (IllegalArgumentException e) {
+ LOG.warn(e.getMessage(), e);
+ throw new IllegalArgument(Throwables.getStackTraceAsString(e));
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public long atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long amount)
+ throws IOError, IllegalArgument, TException {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ if (famAndQf.length == 1) {
+ return atomicIncrement(tableName, row, famAndQf[0], HConstants.EMPTY_BYTE_ARRAY, amount);
+ }
+ return atomicIncrement(tableName, row, famAndQf[0], famAndQf[1], amount);
+ }
+
+ protected long atomicIncrement(ByteBuffer tableName, ByteBuffer row, byte[] family,
+ byte[] qualifier, long amount) throws IOError, IllegalArgument, TException {
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ return table.incrementColumnValue(getBytes(row), family, qualifier, amount);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public void scannerClose(int id) throws IOError, IllegalArgument {
+ LOG.debug("scannerClose: id={}", id);
+ ResultScannerWrapper resultScannerWrapper = getScanner(id);
+ if (resultScannerWrapper == null) {
+ LOG.warn("scanner ID is invalid");
+ throw new IllegalArgument("scanner ID is invalid");
+ }
+ resultScannerWrapper.getScanner().close();
+ removeScanner(id);
+ }
+
+ @Override
+ public List<TRowResult> scannerGetList(int id, int nbRows) throws IllegalArgument, IOError {
+ LOG.debug("scannerGetList: id={}", id);
+ ResultScannerWrapper resultScannerWrapper = getScanner(id);
+ if (null == resultScannerWrapper) {
+ String message = "scanner ID is invalid";
+ LOG.warn(message);
+ throw new IllegalArgument("scanner ID is invalid");
+ }
+
+ Result[] results;
+ try {
+ results = resultScannerWrapper.getScanner().next(nbRows);
+ if (null == results) {
+ return new ArrayList<>();
+ }
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ // Add scanner back to scannerMap; protects against case
+ // where scanner expired during processing of request.
+ scannerMap.put(id, resultScannerWrapper);
+ }
+ return ThriftUtilities.rowResultFromHBase(results, resultScannerWrapper.isColumnSorted());
+ }
+
+ @Override
+ public List<TRowResult> scannerGet(int id) throws IllegalArgument, IOError {
+ return scannerGetList(id, 1);
+ }
+
+ @Override
+ public int scannerOpenWithScan(ByteBuffer tableName, TScan tScan,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Scan scan = new Scan();
+ addAttributes(scan, attributes);
+ if (tScan.isSetStartRow()) {
+ scan.withStartRow(tScan.getStartRow());
+ }
+ if (tScan.isSetStopRow()) {
+ scan.withStopRow(tScan.getStopRow());
+ }
+ if (tScan.isSetTimestamp()) {
+ scan.setTimeRange(0, tScan.getTimestamp());
+ }
+ if (tScan.isSetCaching()) {
+ scan.setCaching(tScan.getCaching());
+ }
+ if (tScan.isSetBatchSize()) {
+ scan.setBatch(tScan.getBatchSize());
+ }
+ if (tScan.isSetColumns() && !tScan.getColumns().isEmpty()) {
+ for (ByteBuffer column : tScan.getColumns()) {
+ byte[][] famQf = CellUtil.parseColumn(getBytes(column));
+ if (famQf.length == 1) {
+ scan.addFamily(famQf[0]);
+ } else {
+ scan.addColumn(famQf[0], famQf[1]);
+ }
+ }
+ }
+ if (tScan.isSetFilterString()) {
+ ParseFilter parseFilter = new ParseFilter();
+ scan.setFilter(parseFilter.parseFilterString(tScan.getFilterString()));
+ }
+ if (tScan.isSetReversed()) {
+ scan.setReversed(tScan.isReversed());
+ }
+ if (tScan.isSetCacheBlocks()) {
+ scan.setCacheBlocks(tScan.isCacheBlocks());
+ }
+ return addScanner(table.getScanner(scan), tScan.sortColumns);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns,
+ Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Scan scan = new Scan().withStartRow(getBytes(startRow));
+ addAttributes(scan, attributes);
+ if (columns != null && !columns.isEmpty()) {
+ for (ByteBuffer column : columns) {
+ byte[][] famQf = CellUtil.parseColumn(getBytes(column));
+ if (famQf.length == 1) {
+ scan.addFamily(famQf[0]);
+ } else {
+ scan.addColumn(famQf[0], famQf[1]);
+ }
+ }
+ }
+ return addScanner(table.getScanner(scan), false);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow,
+ List<ByteBuffer> columns, Map<ByteBuffer, ByteBuffer> attributes) throws IOError, TException {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Scan scan = new Scan().withStartRow(getBytes(startRow)).withStopRow(getBytes(stopRow));
+ addAttributes(scan, attributes);
+ if (columns != null && !columns.isEmpty()) {
+ for (ByteBuffer column : columns) {
+ byte[][] famQf = CellUtil.parseColumn(getBytes(column));
+ if (famQf.length == 1) {
+ scan.addFamily(famQf[0]);
+ } else {
+ scan.addColumn(famQf[0], famQf[1]);
+ }
+ }
+ }
+ return addScanner(table.getScanner(scan), false);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public int scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix,
+ List<ByteBuffer> columns, Map<ByteBuffer, ByteBuffer> attributes) throws IOError, TException {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Scan scan = new Scan().withStartRow(getBytes(startAndPrefix));
+ addAttributes(scan, attributes);
+ Filter f = new WhileMatchFilter(new PrefixFilter(getBytes(startAndPrefix)));
+ scan.setFilter(f);
+ if (columns != null && !columns.isEmpty()) {
+ for (ByteBuffer column : columns) {
+ byte[][] famQf = CellUtil.parseColumn(getBytes(column));
+ if (famQf.length == 1) {
+ scan.addFamily(famQf[0]);
+ } else {
+ scan.addColumn(famQf[0], famQf[1]);
+ }
+ }
+ }
+ return addScanner(table.getScanner(scan), false);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns,
+ long timestamp, Map<ByteBuffer, ByteBuffer> attributes) throws IOError, TException {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Scan scan = new Scan().withStartRow(getBytes(startRow));
+ addAttributes(scan, attributes);
+ scan.setTimeRange(0, timestamp);
+ if (columns != null && !columns.isEmpty()) {
+ for (ByteBuffer column : columns) {
+ byte[][] famQf = CellUtil.parseColumn(getBytes(column));
+ if (famQf.length == 1) {
+ scan.addFamily(famQf[0]);
+ } else {
+ scan.addColumn(famQf[0], famQf[1]);
+ }
+ }
+ }
+ return addScanner(table.getScanner(scan), false);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow,
+ List<ByteBuffer> columns, long timestamp, Map<ByteBuffer, ByteBuffer> attributes)
+ throws IOError, TException {
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ Scan scan = new Scan().withStartRow(getBytes(startRow)).withStopRow(getBytes(stopRow));
+ addAttributes(scan, attributes);
+ scan.setTimeRange(0, timestamp);
+ if (columns != null && !columns.isEmpty()) {
+ for (ByteBuffer column : columns) {
+ byte[][] famQf = CellUtil.parseColumn(getBytes(column));
+ if (famQf.length == 1) {
+ scan.addFamily(famQf[0]);
+ } else {
+ scan.addColumn(famQf[0], famQf[1]);
+ }
+ }
+ }
+ scan.setTimeRange(0, timestamp);
+ return addScanner(table.getScanner(scan), false);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public Map<ByteBuffer, ColumnDescriptor> getColumnDescriptors(ByteBuffer tableName)
+ throws IOError, TException {
+
+ Table table = null;
+ try {
+ TreeMap<ByteBuffer, ColumnDescriptor> columns = new TreeMap<>();
+
+ table = getTable(tableName);
+ TableDescriptor desc = table.getDescriptor();
+
+ for (ColumnFamilyDescriptor e : desc.getColumnFamilies()) {
+ ColumnDescriptor col = ThriftUtilities.colDescFromHbase(e);
+ columns.put(col.name, col);
+ }
+ return columns;
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ private void closeTable(Table table) throws IOError {
+ try {
+ if (table != null) {
+ table.close();
+ }
+ } catch (IOException e) {
+ LOG.error(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ @Override
+ public TRegionInfo getRegionInfo(ByteBuffer searchRow) throws IOError {
+ try {
+ byte[] row = getBytes(searchRow);
+ Result startRowResult =
+ getReverseScanResult(TableName.META_TABLE_NAME.getName(), row, HConstants.CATALOG_FAMILY);
+
+ if (startRowResult == null) {
+ throw new IOException(
+ "Cannot find row in " + TableName.META_TABLE_NAME + ", row=" + Bytes.toStringBinary(row));
+ }
+
+ // find region start and end keys
+ RegionInfo regionInfo = CatalogFamilyFormat.getRegionInfo(startRowResult);
+ if (regionInfo == null) {
+ throw new IOException("RegionInfo REGIONINFO was null or " + " empty in Meta for row="
+ + Bytes.toStringBinary(row));
+ }
+ TRegionInfo region = new TRegionInfo();
+ region.setStartKey(regionInfo.getStartKey());
+ region.setEndKey(regionInfo.getEndKey());
+ region.id = regionInfo.getRegionId();
+ region.setName(regionInfo.getRegionName());
+ region.version = HREGION_VERSION; // version not used anymore, PB encoding used.
+
+ // find region assignment to server
+ ServerName serverName = CatalogFamilyFormat.getServerName(startRowResult, 0);
+ if (serverName != null) {
+ region.setServerName(Bytes.toBytes(serverName.getHostname()));
+ region.port = serverName.getPort();
+ }
+ return region;
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ }
+ }
+
+ private Result getReverseScanResult(byte[] tableName, byte[] row, byte[] family)
+ throws IOException {
+ Scan scan = new Scan().withStartRow(row);
+ scan.setReversed(true);
+ scan.addFamily(family);
+ scan.withStartRow(row);
+ try (Table table = getTable(tableName); ResultScanner scanner = table.getScanner(scan)) {
+ return scanner.next();
+ }
+ }
+
+ @Override
+ public void increment(TIncrement tincrement) throws IOError, TException {
+
+ if (tincrement.getRow().length == 0 || tincrement.getTable().length == 0) {
+ throw new TException("Must supply a table and a row key; can't increment");
+ }
+
+ if (conf.getBoolean(COALESCE_INC_KEY, false)) {
+ this.coalescer.queueIncrement(tincrement);
+ return;
+ }
+
+ Table table = null;
+ try {
+ table = getTable(tincrement.getTable());
+ Increment inc = ThriftUtilities.incrementFromThrift(tincrement);
+ table.increment(inc);
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public void incrementRows(List<TIncrement> tincrements) throws IOError, TException {
+ if (conf.getBoolean(COALESCE_INC_KEY, false)) {
+ this.coalescer.queueIncrements(tincrements);
+ return;
+ }
+ for (TIncrement tinc : tincrements) {
+ increment(tinc);
+ }
+ }
+
+ @Override
+ public List<TCell> append(TAppend tappend) throws IOError, TException {
+ if (tappend.getRow().length == 0 || tappend.getTable().length == 0) {
+ throw new TException("Must supply a table and a row key; can't append");
+ }
+
+ Table table = null;
+ try {
+ table = getTable(tappend.getTable());
+ Append append = ThriftUtilities.appendFromThrift(tappend);
+ Result result = table.append(append);
+ return ThriftUtilities.cellFromHBase(result.rawCells());
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public boolean checkAndPut(ByteBuffer tableName, ByteBuffer row, ByteBuffer column,
+ ByteBuffer value, Mutation mput, Map<ByteBuffer, ByteBuffer> attributes)
+ throws IOError, IllegalArgument, TException {
+ Put put;
+ try {
+ put = new Put(getBytes(row), HConstants.LATEST_TIMESTAMP);
+ addAttributes(put, attributes);
+
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(mput.column));
+ put.add(CellBuilderFactory.create(CellBuilderType.SHALLOW_COPY).setRow(put.getRow())
+ .setFamily(famAndQf[0]).setQualifier(famAndQf[1]).setTimestamp(put.getTimestamp())
+ .setType(Cell.Type.Put)
+ .setValue(mput.value != null ? getBytes(mput.value) : HConstants.EMPTY_BYTE_ARRAY).build());
+ put.setDurability(mput.writeToWAL ? Durability.SYNC_WAL : Durability.SKIP_WAL);
+ } catch (IOException | IllegalArgumentException e) {
+ LOG.warn(e.getMessage(), e);
+ throw new IllegalArgument(Throwables.getStackTraceAsString(e));
+ }
+
+ Table table = null;
+ try {
+ table = getTable(tableName);
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(column));
+ Table.CheckAndMutateBuilder mutateBuilder =
+ table.checkAndMutate(getBytes(row), famAndQf[0]).qualifier(famAndQf[1]);
+ if (value != null) {
+ return mutateBuilder.ifEquals(getBytes(value)).thenPut(put);
+ } else {
+ return mutateBuilder.ifNotExists().thenPut(put);
+ }
+ } catch (IOException e) {
+ LOG.warn(e.getMessage(), e);
+ throw getIOError(e);
+ } catch (IllegalArgumentException e) {
+ LOG.warn(e.getMessage(), e);
+ throw new IllegalArgument(Throwables.getStackTraceAsString(e));
+ } finally {
+ closeTable(table);
+ }
+ }
+
+ @Override
+ public TThriftServerType getThriftServerType() {
+ return TThriftServerType.ONE;
+ }
+
+ @Override
+ public String getClusterId() throws TException {
+ return connectionCache.getClusterId();
+ }
+
+ @Override
+ public boolean grant(TAccessControlEntity info) throws IOError, TException {
+ Permission.Action[] actions = ThriftUtilities.permissionActionsFromString(info.actions);
+ try {
+ if (info.scope == TPermissionScope.NAMESPACE) {
+ AccessControlClient.grant(connectionCache.getAdmin().getConnection(), info.getNsName(),
+ info.getUsername(), actions);
+ } else if (info.scope == TPermissionScope.TABLE) {
+ TableName tableName = TableName.valueOf(info.getTableName());
+ AccessControlClient.grant(connectionCache.getAdmin().getConnection(), tableName,
+ info.getUsername(), null, null, actions);
+ }
+ } catch (Throwable t) {
+ if (t instanceof IOException) {
+ throw getIOError(t);
+ } else {
+ throw getIOError(new DoNotRetryIOException(t.getMessage()));
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public boolean revoke(TAccessControlEntity info) throws IOError, TException {
+ Permission.Action[] actions = ThriftUtilities.permissionActionsFromString(info.actions);
+ try {
+ if (info.scope == TPermissionScope.NAMESPACE) {
+ AccessControlClient.revoke(connectionCache.getAdmin().getConnection(), info.getNsName(),
+ info.getUsername(), actions);
+ } else if (info.scope == TPermissionScope.TABLE) {
+ TableName tableName = TableName.valueOf(info.getTableName());
+ AccessControlClient.revoke(connectionCache.getAdmin().getConnection(), tableName,
+ info.getUsername(), null, null, actions);
+ }
+ } catch (Throwable t) {
+ if (t instanceof IOException) {
+ throw getIOError(t);
+ } else {
+ throw getIOError(new DoNotRetryIOException(t.getMessage()));
+ }
+ }
+ return true;
+ }
+
+ private static IOError getIOError(Throwable throwable) {
+ IOError error = new IOErrorWithCause(throwable);
+ error.setCanRetry(!(throwable instanceof DoNotRetryIOException));
+ error.setMessage(Throwables.getStackTraceAsString(throwable));
+ return error;
+ }
+
+ /**
+ * Adds all the attributes into the Operation object
+ */
+ private static void addAttributes(OperationWithAttributes op,
+ Map<ByteBuffer, ByteBuffer> attributes) {
+ if (attributes == null || attributes.isEmpty()) {
+ return;
+ }
+ for (Map.Entry<ByteBuffer, ByteBuffer> entry : attributes.entrySet()) {
+ String name = Bytes.toStringBinary(getBytes(entry.getKey()));
+ byte[] value = getBytes(entry.getValue());
+ op.setAttribute(name, value);
+ }
+ }
+
+ protected static class ResultScannerWrapper {
+
+ private final ResultScanner scanner;
+ private final boolean sortColumns;
+
+ public ResultScannerWrapper(ResultScanner resultScanner, boolean sortResultColumns) {
+ scanner = resultScanner;
+ sortColumns = sortResultColumns;
+ }
+
+ public ResultScanner getScanner() {
+ return scanner;
+ }
+
+ public boolean isColumnSorted() {
+ return sortColumns;
+ }
+ }
+
+ public static class IOErrorWithCause extends IOError {
+ private final Throwable cause;
+
+ public IOErrorWithCause(Throwable cause) {
+ this.cause = cause;
+ }
+
+ @Override
+ public synchronized Throwable getCause() {
+ return cause;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (super.equals(other) && other instanceof IOErrorWithCause) {
+ Throwable otherCause = ((IOErrorWithCause) other).getCause();
+ if (this.getCause() != null) {
+ return otherCause != null && this.getCause().equals(otherCause);
+ } else {
+ return otherCause == null;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = super.hashCode();
+ result = 31 * result + (cause != null ? cause.hashCode() : 0);
+ return result;
+ }
+ }
+
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHttpServlet.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHttpServlet.java
new file mode 100644
index 0000000..d7b4445
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftHttpServlet.java
@@ -0,0 +1,246 @@
+/*
+ * 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.thrift;
+
+import static org.apache.hadoop.hbase.http.ProxyUserAuthenticationFilter.getDoasFromHeader;
+
+import java.io.IOException;
+import java.security.PrivilegedExceptionAction;
+import java.util.Base64;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.apache.hadoop.hbase.security.SecurityUtil;
+import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.hadoop.security.authorize.AuthorizationException;
+import org.apache.hadoop.security.authorize.ProxyUsers;
+import org.apache.http.HttpHeaders;
+import org.apache.thrift.TProcessor;
+import org.apache.thrift.protocol.TProtocolFactory;
+import org.apache.thrift.server.TServlet;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.ietf.jgss.GSSContext;
+import org.ietf.jgss.GSSCredential;
+import org.ietf.jgss.GSSException;
+import org.ietf.jgss.GSSManager;
+import org.ietf.jgss.GSSName;
+import org.ietf.jgss.Oid;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Thrift Http Servlet is used for performing Kerberos authentication if security is enabled and
+ * also used for setting the user specified in "doAs" parameter.
+ */
+@InterfaceAudience.Private
+public class ThriftHttpServlet extends TServlet {
+ private static final long serialVersionUID = 1L;
+ private static final Logger LOG = LoggerFactory.getLogger(ThriftHttpServlet.class.getName());
+ private final transient UserGroupInformation serviceUGI;
+ private final transient UserGroupInformation httpUGI;
+ private final transient HBaseServiceHandler handler;
+ private final boolean doAsEnabled;
+ private final boolean securityEnabled;
+
+ // HTTP Header related constants.
+ public static final String NEGOTIATE = "Negotiate";
+
+ public ThriftHttpServlet(TProcessor processor, TProtocolFactory protocolFactory,
+ UserGroupInformation serviceUGI, UserGroupInformation httpUGI, HBaseServiceHandler handler,
+ boolean securityEnabled, boolean doAsEnabled) {
+ super(processor, protocolFactory);
+ this.serviceUGI = serviceUGI;
+ this.httpUGI = httpUGI;
+ this.handler = handler;
+ this.securityEnabled = securityEnabled;
+ this.doAsEnabled = doAsEnabled;
+ }
+
+ @Override
+ protected void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ String effectiveUser = request.getRemoteUser();
+ if (securityEnabled) {
+ /*
+ * Check that the AUTHORIZATION header has any content. If it does not then return a 401
+ * requesting AUTHORIZATION header to be sent. This is typical where the first request doesn't
+ * send the AUTHORIZATION header initially.
+ */
+ String authHeader = request.getHeader(HttpHeaders.AUTHORIZATION);
+ if (authHeader == null || authHeader.isEmpty()) {
+ // Send a 401 to the client
+ response.addHeader(HttpHeaders.WWW_AUTHENTICATE, NEGOTIATE);
+ response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
+ return;
+ }
+
+ try {
+ // As Thrift HTTP transport doesn't support SPNEGO yet (THRIFT-889),
+ // Kerberos authentication is being done at servlet level.
+ final RemoteUserIdentity identity = doKerberosAuth(request);
+ effectiveUser = identity.principal;
+ // It is standard for client applications expect this header.
+ // Please see http://tools.ietf.org/html/rfc4559 for more details.
+ response.addHeader(HttpHeaders.WWW_AUTHENTICATE, NEGOTIATE + " " + identity.outToken);
+ } catch (HttpAuthenticationException e) {
+ LOG.error("Kerberos Authentication failed", e);
+ // Send a 401 to the client
+ response.addHeader(HttpHeaders.WWW_AUTHENTICATE, NEGOTIATE);
+ response.sendError(HttpServletResponse.SC_UNAUTHORIZED,
+ "Authentication Error: " + e.getMessage());
+ return;
+ }
+ }
+
+ if (effectiveUser == null) {
+ effectiveUser = serviceUGI.getShortUserName();
+ }
+
+ String doAsUserFromQuery = getDoasFromHeader(request);
+ if (doAsUserFromQuery != null) {
+ if (!doAsEnabled) {
+ throw new ServletException("Support for proxyuser is not configured");
+ }
+ // The authenticated remote user is attempting to perform 'doAs' proxy user.
+ UserGroupInformation remoteUser = UserGroupInformation.createRemoteUser(effectiveUser);
+ // create and attempt to authorize a proxy user (the client is attempting
+ // to do proxy user)
+ UserGroupInformation ugi =
+ UserGroupInformation.createProxyUser(doAsUserFromQuery, remoteUser);
+ // validate the proxy user authorization
+ try {
+ ProxyUsers.authorize(ugi, request.getRemoteAddr());
+ } catch (AuthorizationException e) {
+ throw new ServletException(e);
+ }
+ effectiveUser = doAsUserFromQuery;
+ }
+ handler.setEffectiveUser(effectiveUser);
+ super.doPost(request, response);
+ }
+
+ /**
+ * Do the GSS-API kerberos authentication. We already have a logged in subject in the form of
+ * httpUGI, which GSS-API will extract information from.
+ */
+ private RemoteUserIdentity doKerberosAuth(HttpServletRequest request)
+ throws HttpAuthenticationException {
+ HttpKerberosServerAction action = new HttpKerberosServerAction(request, httpUGI);
+ try {
+ String principal = httpUGI.doAs(action);
+ return new RemoteUserIdentity(principal, action.outToken);
+ } catch (Exception e) {
+ LOG.info("Failed to authenticate with {} kerberos principal", httpUGI.getUserName());
+ throw new HttpAuthenticationException(e);
+ }
+ }
+
+ /**
+ * Basic "struct" class to hold the final base64-encoded, authenticated GSSAPI token for the user
+ * with the given principal talking to the Thrift server.
+ */
+ private static class RemoteUserIdentity {
+ final String outToken;
+ final String principal;
+
+ RemoteUserIdentity(String principal, String outToken) {
+ this.principal = principal;
+ this.outToken = outToken;
+ }
+ }
+
+ private static class HttpKerberosServerAction implements PrivilegedExceptionAction<String> {
+ final HttpServletRequest request;
+ final UserGroupInformation httpUGI;
+ String outToken = null;
+
+ HttpKerberosServerAction(HttpServletRequest request, UserGroupInformation httpUGI) {
+ this.request = request;
+ this.httpUGI = httpUGI;
+ }
+
+ @Override
+ public String run() throws HttpAuthenticationException {
+ // Get own Kerberos credentials for accepting connection
+ GSSManager manager = GSSManager.getInstance();
+ GSSContext gssContext = null;
+ String serverPrincipal = SecurityUtil.getPrincipalWithoutRealm(httpUGI.getUserName());
+ try {
+ // This Oid for Kerberos GSS-API mechanism.
+ Oid kerberosMechOid = new Oid("1.2.840.113554.1.2.2");
+ // Oid for SPNego GSS-API mechanism.
+ Oid spnegoMechOid = new Oid("1.3.6.1.5.5.2");
+ // Oid for kerberos principal name
+ Oid krb5PrincipalOid = new Oid("1.2.840.113554.1.2.2.1");
+ // GSS name for server
+ GSSName serverName = manager.createName(serverPrincipal, krb5PrincipalOid);
+ // GSS credentials for server
+ GSSCredential serverCreds =
+ manager.createCredential(serverName, GSSCredential.DEFAULT_LIFETIME,
+ new Oid[] { kerberosMechOid, spnegoMechOid }, GSSCredential.ACCEPT_ONLY);
+ // Create a GSS context
+ gssContext = manager.createContext(serverCreds);
+ // Get service ticket from the authorization header
+ String serviceTicketBase64 = getAuthHeader(request);
+ byte[] inToken = Base64.getDecoder().decode(serviceTicketBase64);
+ byte[] res = gssContext.acceptSecContext(inToken, 0, inToken.length);
+ if (res != null) {
+ outToken = Base64.getEncoder().encodeToString(res).replace("\n", "");
+ }
+ // Authenticate or deny based on its context completion
+ if (!gssContext.isEstablished()) {
+ throw new HttpAuthenticationException("Kerberos authentication failed: "
+ + "unable to establish context with the service ticket " + "provided by the client.");
+ }
+ return SecurityUtil.getUserFromPrincipal(gssContext.getSrcName().toString());
+ } catch (GSSException e) {
+ throw new HttpAuthenticationException("Kerberos authentication failed: ", e);
+ } finally {
+ if (gssContext != null) {
+ try {
+ gssContext.dispose();
+ } catch (GSSException e) {
+ LOG.warn("Error while disposing GSS Context", e);
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns the base64 encoded auth header payload
+ * @throws HttpAuthenticationException if a remote or network exception occurs
+ */
+ private String getAuthHeader(HttpServletRequest request) throws HttpAuthenticationException {
+ String authHeader = request.getHeader(HttpHeaders.AUTHORIZATION);
+ // Each http request must have an Authorization header
+ if (authHeader == null || authHeader.isEmpty()) {
+ throw new HttpAuthenticationException(
+ "Authorization header received " + "from the client is empty.");
+ }
+ String authHeaderBase64String;
+ int beginIndex = (NEGOTIATE + " ").length();
+ authHeaderBase64String = authHeader.substring(beginIndex);
+ // Authorization header must have a payload
+ if (authHeaderBase64String.isEmpty()) {
+ throw new HttpAuthenticationException(
+ "Authorization header received " + "from the client does not contain any data.");
+ }
+ return authHeaderBase64String;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftMetrics.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftMetrics.java
new file mode 100644
index 0000000..ef609b2
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftMetrics.java
@@ -0,0 +1,179 @@
+/*
+ * 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.thrift;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.CallDroppedException;
+import org.apache.hadoop.hbase.CallQueueTooBigException;
+import org.apache.hadoop.hbase.CompatibilitySingletonFactory;
+import org.apache.hadoop.hbase.MultiActionResultTooLarge;
+import org.apache.hadoop.hbase.NotServingRegionException;
+import org.apache.hadoop.hbase.RegionTooBusyException;
+import org.apache.hadoop.hbase.UnknownScannerException;
+import org.apache.hadoop.hbase.exceptions.ClientExceptionsUtil;
+import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException;
+import org.apache.hadoop.hbase.exceptions.OutOfOrderScannerNextException;
+import org.apache.hadoop.hbase.exceptions.RegionMovedException;
+import org.apache.hadoop.hbase.exceptions.RequestTooBigException;
+import org.apache.hadoop.hbase.exceptions.ScannerResetException;
+import org.apache.hadoop.hbase.quotas.QuotaExceededException;
+import org.apache.hadoop.hbase.quotas.RpcThrottlingException;
+import org.apache.hadoop.hbase.thrift.generated.IOError;
+import org.apache.hadoop.hbase.thrift2.generated.TIOError;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class is for maintaining the various statistics of thrift server and publishing them through
+ * the metrics interfaces.
+ */
+@InterfaceAudience.Private
+public class ThriftMetrics {
+
+ private static final Logger LOG = LoggerFactory.getLogger(ThriftMetrics.class);
+
+ public enum ThriftServerType {
+ ONE,
+ TWO
+ }
+
+ public MetricsThriftServerSource getSource() {
+ return source;
+ }
+
+ public void setSource(MetricsThriftServerSource source) {
+ this.source = source;
+ }
+
+ protected MetricsThriftServerSource source;
+ protected final long slowResponseTime;
+ public static final String SLOW_RESPONSE_NANO_SEC = "hbase.thrift.slow.response.nano.second";
+ public static final long DEFAULT_SLOW_RESPONSE_NANO_SEC = 10 * 1000 * 1000;
+ private final ThriftServerType thriftServerType;
+
+ public ThriftMetrics(Configuration conf, ThriftServerType t) {
+ slowResponseTime = conf.getLong(SLOW_RESPONSE_NANO_SEC, DEFAULT_SLOW_RESPONSE_NANO_SEC);
+ thriftServerType = t;
+ if (t == ThriftServerType.ONE) {
+ source = CompatibilitySingletonFactory.getInstance(MetricsThriftServerSourceFactory.class)
+ .createThriftOneSource();
+ } else if (t == ThriftServerType.TWO) {
+ source = CompatibilitySingletonFactory.getInstance(MetricsThriftServerSourceFactory.class)
+ .createThriftTwoSource();
+ }
+
+ }
+
+ public void incTimeInQueue(long time) {
+ source.incTimeInQueue(time);
+ }
+
+ public void setCallQueueLen(int len) {
+ source.setCallQueueLen(len);
+ }
+
+ public void incNumRowKeysInBatchGet(int diff) {
+ source.incNumRowKeysInBatchGet(diff);
+ }
+
+ public void incNumRowKeysInBatchMutate(int diff) {
+ source.incNumRowKeysInBatchMutate(diff);
+ }
+
+ public void incMethodTime(String name, long time) {
+ source.incMethodTime(name, time);
+ // inc general processTime
+ source.incCall(time);
+ if (time > slowResponseTime) {
+ source.incSlowCall(time);
+ }
+ }
+
+ public void incActiveWorkerCount() {
+ source.incActiveWorkerCount();
+ }
+
+ public void decActiveWorkerCount() {
+ source.decActiveWorkerCount();
+ }
+
+ /**
+ * Increment the count for a specific exception type. This is called for each exception type that
+ * is returned to the thrift handler.
+ * @param rawThrowable type of exception
+ */
+ public void exception(Throwable rawThrowable) {
+ source.exception();
+
+ Throwable throwable = unwrap(rawThrowable);
+ /**
+ * Keep some metrics for commonly seen exceptions Try and put the most common types first. Place
+ * child types before the parent type that they extend. If this gets much larger we might have
+ * to go to a hashmap
+ */
+ if (throwable != null) {
+ if (throwable instanceof OutOfOrderScannerNextException) {
+ source.outOfOrderException();
+ } else if (throwable instanceof RegionTooBusyException) {
+ source.tooBusyException();
+ } else if (throwable instanceof UnknownScannerException) {
+ source.unknownScannerException();
+ } else if (throwable instanceof ScannerResetException) {
+ source.scannerResetException();
+ } else if (throwable instanceof RegionMovedException) {
+ source.movedRegionException();
+ } else if (throwable instanceof NotServingRegionException) {
+ source.notServingRegionException();
+ } else if (throwable instanceof FailedSanityCheckException) {
+ source.failedSanityException();
+ } else if (throwable instanceof MultiActionResultTooLarge) {
+ source.multiActionTooLargeException();
+ } else if (throwable instanceof CallQueueTooBigException) {
+ source.callQueueTooBigException();
+ } else if (throwable instanceof QuotaExceededException) {
+ source.quotaExceededException();
+ } else if (throwable instanceof RpcThrottlingException) {
+ source.rpcThrottlingException();
+ } else if (throwable instanceof CallDroppedException) {
+ source.callDroppedException();
+ } else if (throwable instanceof RequestTooBigException) {
+ source.requestTooBigException();
+ } else {
+ source.otherExceptions();
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Unknown exception type", throwable);
+ }
+ }
+ }
+ }
+
+ protected static Throwable unwrap(Throwable t) {
+ if (t == null) {
+ return t;
+ }
+ if (t instanceof TIOError || t instanceof IOError) {
+ t = t.getCause();
+ }
+ return ClientExceptionsUtil.findException(t);
+ }
+
+ public ThriftServerType getThriftServerType() {
+ return thriftServerType;
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java
new file mode 100644
index 0000000..33bd2ae
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java
@@ -0,0 +1,867 @@
+/*
+ * 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.thrift;
+
+import static org.apache.hadoop.hbase.thrift.Constants.BACKLOG_CONF_DEAFULT;
+import static org.apache.hadoop.hbase.thrift.Constants.BACKLOG_CONF_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.BIND_CONF_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.BIND_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.COMPACT_CONF_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.COMPACT_CONF_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.COMPACT_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.DEFAULT_BIND_ADDR;
+import static org.apache.hadoop.hbase.thrift.Constants.DEFAULT_HTTP_MAX_HEADER_SIZE;
+import static org.apache.hadoop.hbase.thrift.Constants.DEFAULT_LISTEN_PORT;
+import static org.apache.hadoop.hbase.thrift.Constants.FRAMED_CONF_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.FRAMED_CONF_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.FRAMED_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.HTTP_MAX_THREADS_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.HTTP_MAX_THREADS_KEY_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.HTTP_MIN_THREADS_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.HTTP_MIN_THREADS_KEY_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.INFOPORT_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.KEEP_ALIVE_SEC_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.MAX_FRAME_SIZE_CONF_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.MAX_FRAME_SIZE_CONF_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.MAX_QUEUE_SIZE_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.MAX_WORKERS_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.MIN_WORKERS_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.PORT_CONF_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.PORT_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.READ_TIMEOUT_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.SELECTOR_NUM_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_DNS_INTERFACE_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_DNS_NAMESERVER_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_FILTERS;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_HTTP_ALLOW_OPTIONS_METHOD;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_HTTP_ALLOW_OPTIONS_METHOD_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_INFO_SERVER_BINDING_ADDRESS;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_INFO_SERVER_BINDING_ADDRESS_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_INFO_SERVER_PORT;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_INFO_SERVER_PORT_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_KERBEROS_PRINCIPAL_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_KEYTAB_FILE_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_QOP_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SELECTOR_NUM;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SERVER_SOCKET_READ_TIMEOUT_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SERVER_SOCKET_READ_TIMEOUT_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SPNEGO_KEYTAB_FILE_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SPNEGO_PRINCIPAL_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_ENABLED_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_EXCLUDE_CIPHER_SUITES_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_EXCLUDE_PROTOCOLS_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_INCLUDE_CIPHER_SUITES_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_INCLUDE_PROTOCOLS_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_KEYSTORE_KEYPASSWORD_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_KEYSTORE_PASSWORD_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_KEYSTORE_STORE_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_KEYSTORE_TYPE_DEFAULT;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SSL_KEYSTORE_TYPE_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_SUPPORT_PROXYUSER_KEY;
+import static org.apache.hadoop.hbase.thrift.Constants.USE_HTTP_CONF_KEY;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+import java.security.PrivilegedAction;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import javax.security.auth.callback.Callback;
+import javax.security.auth.callback.UnsupportedCallbackException;
+import javax.security.sasl.AuthorizeCallback;
+import javax.security.sasl.SaslServer;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.conf.Configured;
+import org.apache.hadoop.hbase.HBaseConfiguration;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.filter.ParseFilter;
+import org.apache.hadoop.hbase.http.HttpServerUtil;
+import org.apache.hadoop.hbase.http.InfoServer;
+import org.apache.hadoop.hbase.log.HBaseMarkers;
+import org.apache.hadoop.hbase.security.SaslUtil;
+import org.apache.hadoop.hbase.security.SecurityUtil;
+import org.apache.hadoop.hbase.security.UserProvider;
+import org.apache.hadoop.hbase.thrift.generated.Hbase;
+import org.apache.hadoop.hbase.util.DNS;
+import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
+import org.apache.hadoop.hbase.util.JvmPauseMonitor;
+import org.apache.hadoop.hbase.util.Strings;
+import org.apache.hadoop.hbase.util.VersionInfo;
+import org.apache.hadoop.security.SaslRpcServer;
+import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.hadoop.security.authorize.ProxyUsers;
+import org.apache.hadoop.util.Shell.ExitCodeException;
+import org.apache.hadoop.util.Tool;
+import org.apache.hadoop.util.ToolRunner;
+import org.apache.thrift.TProcessor;
+import org.apache.thrift.protocol.TBinaryProtocol;
+import org.apache.thrift.protocol.TCompactProtocol;
+import org.apache.thrift.protocol.TProtocolFactory;
+import org.apache.thrift.server.THsHaServer;
+import org.apache.thrift.server.TNonblockingServer;
+import org.apache.thrift.server.TServer;
+import org.apache.thrift.server.TServlet;
+import org.apache.thrift.server.TThreadedSelectorServer;
+import org.apache.thrift.transport.TNonblockingServerSocket;
+import org.apache.thrift.transport.TNonblockingServerTransport;
+import org.apache.thrift.transport.TSaslServerTransport;
+import org.apache.thrift.transport.TServerSocket;
+import org.apache.thrift.transport.TServerTransport;
+import org.apache.thrift.transport.TTransportFactory;
+import org.apache.thrift.transport.layered.TFramedTransport;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.com.google.common.base.Joiner;
+import org.apache.hbase.thirdparty.com.google.common.base.Splitter;
+import org.apache.hbase.thirdparty.com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.CommandLine;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.CommandLineParser;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.DefaultParser;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.HelpFormatter;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.Options;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.http.HttpVersion;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.server.HttpConfiguration;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.server.HttpConnectionFactory;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.server.SecureRequestCustomizer;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.server.Server;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.server.ServerConnector;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.server.SslConnectionFactory;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.servlet.ServletContextHandler;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.servlet.ServletHolder;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.util.ssl.SslContextFactory;
+import org.apache.hbase.thirdparty.org.eclipse.jetty.util.thread.QueuedThreadPool;
+
+/**
+ * ThriftServer- this class starts up a Thrift server which implements the Hbase API specified in
+ * the Hbase.thrift IDL file. The server runs in an independent process.
+ */
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.TOOLS)
+public class ThriftServer extends Configured implements Tool {
+
+ private static final Logger LOG = LoggerFactory.getLogger(ThriftServer.class);
+
+ protected Configuration conf;
+
+ protected InfoServer infoServer;
+
+ protected TProcessor processor;
+
+ protected ThriftMetrics metrics;
+ protected HBaseServiceHandler hbaseServiceHandler;
+ protected UserGroupInformation serviceUGI;
+ protected UserGroupInformation httpUGI;
+ protected boolean httpEnabled;
+
+ protected SaslUtil.QualityOfProtection qop;
+ protected String host;
+ protected int listenPort;
+
+ protected boolean securityEnabled;
+ protected boolean doAsEnabled;
+
+ protected JvmPauseMonitor pauseMonitor;
+
+ protected volatile TServer tserver;
+ protected volatile Server httpServer;
+
+ //
+ // Main program and support routines
+ //
+
+ public ThriftServer(Configuration conf) {
+ this.conf = HBaseConfiguration.create(conf);
+ }
+
+ protected ThriftMetrics createThriftMetrics(Configuration conf) {
+ return new ThriftMetrics(conf, ThriftMetrics.ThriftServerType.ONE);
+ }
+
+ protected void setupParamters() throws IOException {
+ // login the server principal (if using secure Hadoop)
+ UserProvider userProvider = UserProvider.instantiate(conf);
+ securityEnabled =
+ userProvider.isHadoopSecurityEnabled() && userProvider.isHBaseSecurityEnabled();
+ if (securityEnabled) {
+ host = Strings.domainNamePointerToHostName(
+ DNS.getDefaultHost(conf.get(THRIFT_DNS_INTERFACE_KEY, "default"),
+ conf.get(THRIFT_DNS_NAMESERVER_KEY, "default")));
+ userProvider.login(THRIFT_KEYTAB_FILE_KEY, THRIFT_KERBEROS_PRINCIPAL_KEY, host);
+
+ // Setup the SPNEGO user for HTTP if configured
+ String spnegoPrincipal = getSpengoPrincipal(conf, host);
+ String spnegoKeytab = getSpnegoKeytab(conf);
+ UserGroupInformation.setConfiguration(conf);
+ // login the SPNEGO principal using UGI to avoid polluting the login user
+ this.httpUGI =
+ UserGroupInformation.loginUserFromKeytabAndReturnUGI(spnegoPrincipal, spnegoKeytab);
+ }
+ this.serviceUGI = userProvider.getCurrent().getUGI();
+ if (httpUGI == null) {
+ this.httpUGI = serviceUGI;
+ }
+
+ this.listenPort = conf.getInt(PORT_CONF_KEY, DEFAULT_LISTEN_PORT);
+ this.metrics = createThriftMetrics(conf);
+ this.pauseMonitor = new JvmPauseMonitor(conf, this.metrics.getSource());
+ this.hbaseServiceHandler = createHandler(conf, userProvider);
+ this.hbaseServiceHandler.initMetrics(metrics);
+ this.processor = createProcessor();
+
+ httpEnabled = conf.getBoolean(USE_HTTP_CONF_KEY, false);
+ doAsEnabled = conf.getBoolean(THRIFT_SUPPORT_PROXYUSER_KEY, false);
+ if (doAsEnabled && !httpEnabled) {
+ LOG.warn("Fail to enable the doAs feature. " + USE_HTTP_CONF_KEY + " is not configured");
+ }
+
+ String strQop = conf.get(THRIFT_QOP_KEY);
+ if (strQop != null) {
+ this.qop = SaslUtil.getQop(strQop);
+ }
+ if (qop != null) {
+ if (
+ qop != SaslUtil.QualityOfProtection.AUTHENTICATION
+ && qop != SaslUtil.QualityOfProtection.INTEGRITY
+ && qop != SaslUtil.QualityOfProtection.PRIVACY
+ ) {
+ throw new IOException(String.format("Invalid %s: It must be one of %s, %s, or %s.",
+ THRIFT_QOP_KEY, SaslUtil.QualityOfProtection.AUTHENTICATION.name(),
+ SaslUtil.QualityOfProtection.INTEGRITY.name(),
+ SaslUtil.QualityOfProtection.PRIVACY.name()));
+ }
+ checkHttpSecurity(qop, conf);
+ if (!securityEnabled) {
+ throw new IOException("Thrift server must run in secure mode to support authentication");
+ }
+ }
+ registerFilters(conf);
+ pauseMonitor.start();
+ }
+
+ private String getSpengoPrincipal(Configuration conf, String host) throws IOException {
+ String principal = conf.get(THRIFT_SPNEGO_PRINCIPAL_KEY);
+ if (principal == null) {
+ // We cannot use the Hadoop configuration deprecation handling here since
+ // the THRIFT_KERBEROS_PRINCIPAL_KEY config is still valid for regular Kerberos
+ // communication. The preference should be to use the THRIFT_SPNEGO_PRINCIPAL_KEY
+ // config so that THRIFT_KERBEROS_PRINCIPAL_KEY doesn't control both backend
+ // Kerberos principal and SPNEGO principal.
+ LOG.info("Using deprecated {} config for SPNEGO principal. Use {} instead.",
+ THRIFT_KERBEROS_PRINCIPAL_KEY, THRIFT_SPNEGO_PRINCIPAL_KEY);
+ principal = conf.get(THRIFT_KERBEROS_PRINCIPAL_KEY);
+ }
+ // Handle _HOST in principal value
+ return org.apache.hadoop.security.SecurityUtil.getServerPrincipal(principal, host);
+ }
+
+ private String getSpnegoKeytab(Configuration conf) {
+ String keytab = conf.get(THRIFT_SPNEGO_KEYTAB_FILE_KEY);
+ if (keytab == null) {
+ // We cannot use the Hadoop configuration deprecation handling here since
+ // the THRIFT_KEYTAB_FILE_KEY config is still valid for regular Kerberos
+ // communication. The preference should be to use the THRIFT_SPNEGO_KEYTAB_FILE_KEY
+ // config so that THRIFT_KEYTAB_FILE_KEY doesn't control both backend
+ // Kerberos keytab and SPNEGO keytab.
+ LOG.info("Using deprecated {} config for SPNEGO keytab. Use {} instead.",
+ THRIFT_KEYTAB_FILE_KEY, THRIFT_SPNEGO_KEYTAB_FILE_KEY);
+ keytab = conf.get(THRIFT_KEYTAB_FILE_KEY);
+ }
+ return keytab;
+ }
+
+ protected void startInfoServer() throws IOException {
+ // Put up info server.
+ int port = conf.getInt(THRIFT_INFO_SERVER_PORT, THRIFT_INFO_SERVER_PORT_DEFAULT);
+
+ if (port >= 0) {
+ conf.setLong("startcode", EnvironmentEdgeManager.currentTime());
+ String a =
+ conf.get(THRIFT_INFO_SERVER_BINDING_ADDRESS, THRIFT_INFO_SERVER_BINDING_ADDRESS_DEFAULT);
+ infoServer = new InfoServer("thrift", a, port, false, conf);
+ infoServer.setAttribute("hbase.conf", conf);
+ infoServer.setAttribute("hbase.thrift.server.type", metrics.getThriftServerType().name());
+ infoServer.start();
+ }
+ }
+
+ protected void checkHttpSecurity(SaslUtil.QualityOfProtection qop, Configuration conf) {
+ if (
+ qop == SaslUtil.QualityOfProtection.PRIVACY && conf.getBoolean(USE_HTTP_CONF_KEY, false)
+ && !conf.getBoolean(THRIFT_SSL_ENABLED_KEY, false)
+ ) {
+ throw new IllegalArgumentException(
+ "Thrift HTTP Server's QoP is privacy, but " + THRIFT_SSL_ENABLED_KEY + " is false");
+ }
+ }
+
+ protected HBaseServiceHandler createHandler(Configuration conf, UserProvider userProvider)
+ throws IOException {
+ return new ThriftHBaseServiceHandler(conf, userProvider);
+ }
+
+ protected TProcessor createProcessor() {
+ return new Hbase.Processor<>(
+ HbaseHandlerMetricsProxy.newInstance((Hbase.Iface) hbaseServiceHandler, metrics, conf));
+ }
+
+ /**
+ * the thrift server, not null means the server is started, for test only
+ * @return the tServer
+ */
+ @InterfaceAudience.Private
+ public TServer getTserver() {
+ return tserver;
+ }
+
+ /**
+ * the Jetty server, not null means the HTTP server is started, for test only
+ * @return the http server
+ */
+ @InterfaceAudience.Private
+ public Server getHttpServer() {
+ return httpServer;
+ }
+
+ protected void printUsageAndExit(Options options, int exitCode) throws ExitCodeException {
+ HelpFormatter formatter = new HelpFormatter();
+ formatter.printHelp("Thrift", null, options,
+ "To start the Thrift server run 'hbase-daemon.sh start thrift' or " + "'hbase thrift'\n"
+ + "To shutdown the thrift server run 'hbase-daemon.sh stop "
+ + "thrift' or send a kill signal to the thrift server pid",
+ true);
+ throw new ExitCodeException(exitCode, "");
+ }
+
+ /**
+ * Create a Servlet for the http server
+ * @param protocolFactory protocolFactory
+ * @return the servlet
+ */
+ protected TServlet createTServlet(TProtocolFactory protocolFactory) {
+ return new ThriftHttpServlet(processor, protocolFactory, serviceUGI, httpUGI,
+ hbaseServiceHandler, securityEnabled, doAsEnabled);
+ }
+
+ /**
+ * Setup an HTTP Server using Jetty to serve calls from THttpClient
+ * @throws IOException IOException
+ */
+ protected void setupHTTPServer() throws IOException {
+ TProtocolFactory protocolFactory = new TBinaryProtocol.Factory();
+ TServlet thriftHttpServlet = createTServlet(protocolFactory);
+
+ // Set the default max thread number to 100 to limit
+ // the number of concurrent requests so that Thrfit HTTP server doesn't OOM easily.
+ // Jetty set the default max thread number to 250, if we don't set it.
+ //
+ // Our default min thread number 2 is the same as that used by Jetty.
+ int minThreads = conf.getInt(HTTP_MIN_THREADS_KEY, conf
+ .getInt(TBoundedThreadPoolServer.MIN_WORKER_THREADS_CONF_KEY, HTTP_MIN_THREADS_KEY_DEFAULT));
+ int maxThreads = conf.getInt(HTTP_MAX_THREADS_KEY, conf
+ .getInt(TBoundedThreadPoolServer.MAX_WORKER_THREADS_CONF_KEY, HTTP_MAX_THREADS_KEY_DEFAULT));
+ QueuedThreadPool threadPool = new QueuedThreadPool(maxThreads);
+ threadPool.setMinThreads(minThreads);
+ httpServer = new Server(threadPool);
+
+ // Context handler
+ ServletContextHandler ctxHandler =
+ new ServletContextHandler(httpServer, "/", ServletContextHandler.SESSIONS);
+ ctxHandler.addServlet(new ServletHolder(thriftHttpServlet), "/*");
+ HttpServerUtil.constrainHttpMethods(ctxHandler,
+ conf.getBoolean(THRIFT_HTTP_ALLOW_OPTIONS_METHOD, THRIFT_HTTP_ALLOW_OPTIONS_METHOD_DEFAULT));
+
+ // set up Jetty and run the embedded server
+ HttpConfiguration httpConfig = new HttpConfiguration();
+ httpConfig.setSecureScheme("https");
+ httpConfig.setSecurePort(listenPort);
+ httpConfig.setHeaderCacheSize(DEFAULT_HTTP_MAX_HEADER_SIZE);
+ httpConfig.setRequestHeaderSize(DEFAULT_HTTP_MAX_HEADER_SIZE);
+ httpConfig.setResponseHeaderSize(DEFAULT_HTTP_MAX_HEADER_SIZE);
+ httpConfig.setSendServerVersion(false);
+ httpConfig.setSendDateHeader(false);
+
+ ServerConnector serverConnector;
+ if (conf.getBoolean(THRIFT_SSL_ENABLED_KEY, false)) {
+ HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
+ httpsConfig.addCustomizer(new SecureRequestCustomizer());
+
+ SslContextFactory.Server sslCtxFactory = new SslContextFactory.Server();
+ String keystore = conf.get(THRIFT_SSL_KEYSTORE_STORE_KEY);
+ String password =
+ HBaseConfiguration.getPassword(conf, THRIFT_SSL_KEYSTORE_PASSWORD_KEY, null);
+ String keyPassword =
+ HBaseConfiguration.getPassword(conf, THRIFT_SSL_KEYSTORE_KEYPASSWORD_KEY, password);
+ sslCtxFactory.setKeyStorePath(keystore);
+ sslCtxFactory.setKeyStorePassword(password);
+ sslCtxFactory.setKeyManagerPassword(keyPassword);
+ sslCtxFactory
+ .setKeyStoreType(conf.get(THRIFT_SSL_KEYSTORE_TYPE_KEY, THRIFT_SSL_KEYSTORE_TYPE_DEFAULT));
+
+ String[] excludeCiphers =
+ conf.getStrings(THRIFT_SSL_EXCLUDE_CIPHER_SUITES_KEY, ArrayUtils.EMPTY_STRING_ARRAY);
+ if (excludeCiphers.length != 0) {
+ sslCtxFactory.setExcludeCipherSuites(excludeCiphers);
+ }
+ String[] includeCiphers =
+ conf.getStrings(THRIFT_SSL_INCLUDE_CIPHER_SUITES_KEY, ArrayUtils.EMPTY_STRING_ARRAY);
+ if (includeCiphers.length != 0) {
+ sslCtxFactory.setIncludeCipherSuites(includeCiphers);
+ }
+
+ // Disable SSLv3 by default due to "Poodle" Vulnerability - CVE-2014-3566
+ String[] excludeProtocols = conf.getStrings(THRIFT_SSL_EXCLUDE_PROTOCOLS_KEY, "SSLv3");
+ if (excludeProtocols.length != 0) {
+ sslCtxFactory.setExcludeProtocols(excludeProtocols);
+ }
+ String[] includeProtocols =
+ conf.getStrings(THRIFT_SSL_INCLUDE_PROTOCOLS_KEY, ArrayUtils.EMPTY_STRING_ARRAY);
+ if (includeProtocols.length != 0) {
+ sslCtxFactory.setIncludeProtocols(includeProtocols);
+ }
+
+ serverConnector = new ServerConnector(httpServer,
+ new SslConnectionFactory(sslCtxFactory, HttpVersion.HTTP_1_1.toString()),
+ new HttpConnectionFactory(httpsConfig));
+ } else {
+ serverConnector = new ServerConnector(httpServer, new HttpConnectionFactory(httpConfig));
+ }
+ serverConnector.setPort(listenPort);
+ serverConnector.setHost(getBindAddress(conf).getHostAddress());
+ httpServer.addConnector(serverConnector);
+ httpServer.setStopAtShutdown(true);
+
+ if (doAsEnabled) {
+ ProxyUsers.refreshSuperUserGroupsConfiguration(conf);
+ }
+ LOG.info("Starting Thrift HTTP Server on {}", Integer.toString(listenPort));
+ }
+
+ /**
+ * Setting up the thrift TServer
+ */
+ protected void setupServer() throws Exception {
+ // Construct correct ProtocolFactory
+ TProtocolFactory protocolFactory = getProtocolFactory();
+
+ ImplType implType = ImplType.getServerImpl(conf);
+ TProcessor processorToUse = processor;
+
+ // Construct correct TransportFactory
+ TTransportFactory transportFactory;
+ if (conf.getBoolean(FRAMED_CONF_KEY, FRAMED_CONF_DEFAULT) || implType.isAlwaysFramed) {
+ if (qop != null) {
+ throw new RuntimeException(
+ "Thrift server authentication" + " doesn't work with framed transport yet");
+ }
+ transportFactory = new TFramedTransport.Factory(
+ conf.getInt(MAX_FRAME_SIZE_CONF_KEY, MAX_FRAME_SIZE_CONF_DEFAULT) * 1024 * 1024);
+ LOG.debug("Using framed transport");
+ } else if (qop == null) {
+ transportFactory = new TTransportFactory();
+ } else {
+ // Extract the name from the principal
+ String thriftKerberosPrincipal = conf.get(THRIFT_KERBEROS_PRINCIPAL_KEY);
+ if (thriftKerberosPrincipal == null) {
+ throw new IllegalArgumentException(THRIFT_KERBEROS_PRINCIPAL_KEY + " cannot be null");
+ }
+ String name = SecurityUtil.getUserFromPrincipal(thriftKerberosPrincipal);
+ Map<String, String> saslProperties = SaslUtil.initSaslProperties(qop.name());
+ TSaslServerTransport.Factory saslFactory = new TSaslServerTransport.Factory();
+ saslFactory.addServerDefinition("GSSAPI", name, host, saslProperties,
+ new SaslRpcServer.SaslGssCallbackHandler() {
+ @Override
+ public void handle(Callback[] callbacks) throws UnsupportedCallbackException {
+ AuthorizeCallback ac = null;
+ for (Callback callback : callbacks) {
+ if (callback instanceof AuthorizeCallback) {
+ ac = (AuthorizeCallback) callback;
+ } else {
+ throw new UnsupportedCallbackException(callback,
+ "Unrecognized SASL GSSAPI Callback");
+ }
+ }
+ if (ac != null) {
+ String authid = ac.getAuthenticationID();
+ String authzid = ac.getAuthorizationID();
+ if (!authid.equals(authzid)) {
+ ac.setAuthorized(false);
+ } else {
+ ac.setAuthorized(true);
+ String userName = SecurityUtil.getUserFromPrincipal(authzid);
+ LOG.info("Effective user: {}", userName);
+ ac.setAuthorizedID(userName);
+ }
+ }
+ }
+ });
+ transportFactory = saslFactory;
+
+ // Create a processor wrapper, to get the caller
+ processorToUse = (inProt, outProt) -> {
+ TSaslServerTransport saslServerTransport = (TSaslServerTransport) inProt.getTransport();
+ SaslServer saslServer = saslServerTransport.getSaslServer();
+ String principal = saslServer.getAuthorizationID();
+ hbaseServiceHandler.setEffectiveUser(principal);
+ processor.process(inProt, outProt);
+ };
+ }
+
+ if (conf.get(BIND_CONF_KEY) != null && !implType.canSpecifyBindIP) {
+ LOG.error(
+ "Server types {} don't support IP address binding at the moment. See "
+ + "https://issues.apache.org/jira/browse/HBASE-2155 for details.",
+ Joiner.on(", ").join(ImplType.serversThatCannotSpecifyBindIP()));
+ throw new RuntimeException("-" + BIND_CONF_KEY + " not supported with " + implType);
+ }
+
+ InetSocketAddress inetSocketAddress = new InetSocketAddress(getBindAddress(conf), listenPort);
+ if (
+ implType == ImplType.HS_HA || implType == ImplType.NONBLOCKING
+ || implType == ImplType.THREADED_SELECTOR
+ ) {
+ TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(inetSocketAddress);
+ if (implType == ImplType.NONBLOCKING) {
+ tserver = getTNonBlockingServer(serverTransport, protocolFactory, processorToUse,
+ transportFactory, inetSocketAddress);
+ } else if (implType == ImplType.HS_HA) {
+ tserver = getTHsHaServer(serverTransport, protocolFactory, processorToUse, transportFactory,
+ inetSocketAddress);
+ } else { // THREADED_SELECTOR
+ tserver = getTThreadedSelectorServer(serverTransport, protocolFactory, processorToUse,
+ transportFactory, inetSocketAddress);
+ }
+ LOG.info("starting HBase {} server on {}", implType.simpleClassName(),
+ Integer.toString(listenPort));
+ } else if (implType == ImplType.THREAD_POOL) {
+ this.tserver =
+ getTThreadPoolServer(protocolFactory, processorToUse, transportFactory, inetSocketAddress);
+ } else {
+ throw new AssertionError(
+ "Unsupported Thrift server implementation: " + implType.simpleClassName());
+ }
+
+ // A sanity check that we instantiated the right type of server.
+ if (tserver.getClass() != implType.serverClass) {
+ throw new AssertionError("Expected to create Thrift server class "
+ + implType.serverClass.getName() + " but got " + tserver.getClass().getName());
+ }
+ }
+
+ protected TServer getTNonBlockingServer(TNonblockingServerTransport serverTransport,
+ TProtocolFactory protocolFactory, TProcessor processor, TTransportFactory transportFactory,
+ InetSocketAddress inetSocketAddress) {
+ LOG.info("starting HBase Nonblocking Thrift server on " + inetSocketAddress.toString());
+ TNonblockingServer.Args serverArgs = new TNonblockingServer.Args(serverTransport);
+ serverArgs.processor(processor);
+ serverArgs.transportFactory(transportFactory);
+ serverArgs.protocolFactory(protocolFactory);
+ return new TNonblockingServer(serverArgs);
+ }
+
+ protected TServer getTHsHaServer(TNonblockingServerTransport serverTransport,
+ TProtocolFactory protocolFactory, TProcessor processor, TTransportFactory transportFactory,
+ InetSocketAddress inetSocketAddress) {
+ LOG.info("starting HBase HsHA Thrift server on " + inetSocketAddress.toString());
+ THsHaServer.Args serverArgs = new THsHaServer.Args(serverTransport);
+ int queueSize = conf.getInt(TBoundedThreadPoolServer.MAX_QUEUED_REQUESTS_CONF_KEY,
+ TBoundedThreadPoolServer.DEFAULT_MAX_QUEUED_REQUESTS);
+ CallQueue callQueue = new CallQueue(new LinkedBlockingQueue<>(queueSize), metrics);
+ int workerThread = conf.getInt(TBoundedThreadPoolServer.MAX_WORKER_THREADS_CONF_KEY,
+ serverArgs.getMaxWorkerThreads());
+ ExecutorService executorService = createExecutor(callQueue, workerThread, workerThread);
+ serverArgs.executorService(executorService).processor(processor)
+ .transportFactory(transportFactory).protocolFactory(protocolFactory);
+ return new THsHaServer(serverArgs);
+ }
+
+ protected TServer getTThreadedSelectorServer(TNonblockingServerTransport serverTransport,
+ TProtocolFactory protocolFactory, TProcessor processor, TTransportFactory transportFactory,
+ InetSocketAddress inetSocketAddress) {
+ LOG.info("starting HBase ThreadedSelector Thrift server on " + inetSocketAddress.toString());
+ TThreadedSelectorServer.Args serverArgs =
+ new HThreadedSelectorServerArgs(serverTransport, conf);
+ int queueSize = conf.getInt(TBoundedThreadPoolServer.MAX_QUEUED_REQUESTS_CONF_KEY,
+ TBoundedThreadPoolServer.DEFAULT_MAX_QUEUED_REQUESTS);
+ CallQueue callQueue = new CallQueue(new LinkedBlockingQueue<>(queueSize), metrics);
+ int workerThreads = conf.getInt(TBoundedThreadPoolServer.MAX_WORKER_THREADS_CONF_KEY,
+ serverArgs.getWorkerThreads());
+ int selectorThreads = conf.getInt(THRIFT_SELECTOR_NUM, serverArgs.getSelectorThreads());
+ serverArgs.selectorThreads(selectorThreads);
+ ExecutorService executorService = createExecutor(callQueue, workerThreads, workerThreads);
+ serverArgs.executorService(executorService).processor(processor)
+ .transportFactory(transportFactory).protocolFactory(protocolFactory);
+ return new TThreadedSelectorServer(serverArgs);
+ }
+
+ protected TServer getTThreadPoolServer(TProtocolFactory protocolFactory, TProcessor processor,
+ TTransportFactory transportFactory, InetSocketAddress inetSocketAddress) throws Exception {
+ LOG.info("starting HBase ThreadPool Thrift server on " + inetSocketAddress.toString());
+ // Thrift's implementation uses '0' as a placeholder for 'use the default.'
+ int backlog = conf.getInt(BACKLOG_CONF_KEY, BACKLOG_CONF_DEAFULT);
+ int readTimeout =
+ conf.getInt(THRIFT_SERVER_SOCKET_READ_TIMEOUT_KEY, THRIFT_SERVER_SOCKET_READ_TIMEOUT_DEFAULT);
+ TServerTransport serverTransport =
+ new TServerSocket(new TServerSocket.ServerSocketTransportArgs().bindAddr(inetSocketAddress)
+ .backlog(backlog).clientTimeout(readTimeout));
+
+ TBoundedThreadPoolServer.Args serverArgs =
+ new TBoundedThreadPoolServer.Args(serverTransport, conf);
+ serverArgs.processor(processor).transportFactory(transportFactory)
+ .protocolFactory(protocolFactory);
+ return new TBoundedThreadPoolServer(serverArgs, metrics);
+ }
+
+ protected TProtocolFactory getProtocolFactory() {
+ TProtocolFactory protocolFactory;
+
+ if (conf.getBoolean(COMPACT_CONF_KEY, COMPACT_CONF_DEFAULT)) {
+ LOG.debug("Using compact protocol");
+ protocolFactory = new TCompactProtocol.Factory();
+ } else {
+ LOG.debug("Using binary protocol");
+ protocolFactory = new TBinaryProtocol.Factory();
+ }
+
+ return protocolFactory;
+ }
+
+ protected ExecutorService createExecutor(BlockingQueue<Runnable> callQueue, int minWorkers,
+ int maxWorkers) {
+ ThreadFactoryBuilder tfb = new ThreadFactoryBuilder();
+ tfb.setDaemon(true);
+ tfb.setNameFormat("thrift-worker-%d");
+ ThreadPoolExecutor threadPool = new THBaseThreadPoolExecutor(minWorkers, maxWorkers,
+ Long.MAX_VALUE, TimeUnit.SECONDS, callQueue, tfb.build(), metrics);
+ threadPool.allowCoreThreadTimeOut(true);
+ return threadPool;
+ }
+
+ protected InetAddress getBindAddress(Configuration conf) throws UnknownHostException {
+ String bindAddressStr = conf.get(BIND_CONF_KEY, DEFAULT_BIND_ADDR);
+ return InetAddress.getByName(bindAddressStr);
+ }
+
+ public static void registerFilters(Configuration conf) {
+ String[] filters = conf.getStrings(THRIFT_FILTERS);
+ Splitter splitter = Splitter.on(':');
+ if (filters != null) {
+ for (String filterClass : filters) {
+ List<String> filterPart = splitter.splitToList(filterClass);
+ if (filterPart.size() != 2) {
+ LOG.warn("Invalid filter specification " + filterClass + " - skipping");
+ } else {
+ ParseFilter.registerFilter(filterPart.get(0), filterPart.get(1));
+ }
+ }
+ }
+ }
+
+ /**
+ * Add options to command lines
+ * @param options options
+ */
+ protected void addOptions(Options options) {
+ options.addOption("b", BIND_OPTION, true,
+ "Address to bind " + "the Thrift server to. [default: " + DEFAULT_BIND_ADDR + "]");
+ options.addOption("p", PORT_OPTION, true,
+ "Port to bind to [default: " + DEFAULT_LISTEN_PORT + "]");
+ options.addOption("f", FRAMED_OPTION, false, "Use framed transport");
+ options.addOption("c", COMPACT_OPTION, false, "Use the compact protocol");
+ options.addOption("h", "help", false, "Print help information");
+ options.addOption("s", SELECTOR_NUM_OPTION, true, "How many selector threads to use.");
+ options.addOption(null, INFOPORT_OPTION, true, "Port for web UI");
+
+ options.addOption("m", MIN_WORKERS_OPTION, true,
+ "The minimum number of worker threads for " + ImplType.THREAD_POOL.simpleClassName());
+
+ options.addOption("w", MAX_WORKERS_OPTION, true,
+ "The maximum number of worker threads for " + ImplType.THREAD_POOL.simpleClassName());
+
+ options.addOption("q", MAX_QUEUE_SIZE_OPTION, true,
+ "The maximum number of queued requests in " + ImplType.THREAD_POOL.simpleClassName());
+
+ options.addOption("k", KEEP_ALIVE_SEC_OPTION, true,
+ "The amount of time in secods to keep a thread alive when idle in "
+ + ImplType.THREAD_POOL.simpleClassName());
+
+ options.addOption("t", READ_TIMEOUT_OPTION, true,
+ "Amount of time in milliseconds before a server thread will timeout "
+ + "waiting for client to send data on a connected socket. Currently, "
+ + "only applies to TBoundedThreadPoolServer");
+
+ options.addOptionGroup(ImplType.createOptionGroup());
+ }
+
+ protected void parseCommandLine(CommandLine cmd, Options options) throws ExitCodeException {
+ // Get port to bind to
+ try {
+ if (cmd.hasOption(PORT_OPTION)) {
+ int listenPort = Integer.parseInt(cmd.getOptionValue(PORT_OPTION));
+ conf.setInt(PORT_CONF_KEY, listenPort);
+ }
+ } catch (NumberFormatException e) {
+ LOG.error("Could not parse the value provided for the port option", e);
+ printUsageAndExit(options, -1);
+ }
+ // check for user-defined info server port setting, if so override the conf
+ try {
+ if (cmd.hasOption(INFOPORT_OPTION)) {
+ String val = cmd.getOptionValue(INFOPORT_OPTION);
+ conf.setInt(THRIFT_INFO_SERVER_PORT, Integer.parseInt(val));
+ LOG.debug("Web UI port set to " + val);
+ }
+ } catch (NumberFormatException e) {
+ LOG.error("Could not parse the value provided for the " + INFOPORT_OPTION + " option", e);
+ printUsageAndExit(options, -1);
+ }
+ // Make optional changes to the configuration based on command-line options
+ optionToConf(cmd, MIN_WORKERS_OPTION, conf,
+ TBoundedThreadPoolServer.MIN_WORKER_THREADS_CONF_KEY);
+ optionToConf(cmd, MAX_WORKERS_OPTION, conf,
+ TBoundedThreadPoolServer.MAX_WORKER_THREADS_CONF_KEY);
+ optionToConf(cmd, MAX_QUEUE_SIZE_OPTION, conf,
+ TBoundedThreadPoolServer.MAX_QUEUED_REQUESTS_CONF_KEY);
+ optionToConf(cmd, KEEP_ALIVE_SEC_OPTION, conf,
+ TBoundedThreadPoolServer.THREAD_KEEP_ALIVE_TIME_SEC_CONF_KEY);
+ optionToConf(cmd, READ_TIMEOUT_OPTION, conf, THRIFT_SERVER_SOCKET_READ_TIMEOUT_KEY);
+ optionToConf(cmd, SELECTOR_NUM_OPTION, conf, THRIFT_SELECTOR_NUM);
+
+ // Set general thrift server options
+ boolean compact = cmd.hasOption(COMPACT_OPTION) || conf.getBoolean(COMPACT_CONF_KEY, false);
+ conf.setBoolean(COMPACT_CONF_KEY, compact);
+ boolean framed = cmd.hasOption(FRAMED_OPTION) || conf.getBoolean(FRAMED_CONF_KEY, false);
+ conf.setBoolean(FRAMED_CONF_KEY, framed);
+
+ optionToConf(cmd, BIND_OPTION, conf, BIND_CONF_KEY);
+
+ ImplType.setServerImpl(cmd, conf);
+ }
+
+ /**
+ * Parse the command line options to set parameters the conf.
+ */
+ protected void processOptions(final String[] args) throws Exception {
+ if (args == null || args.length == 0) {
+ return;
+ }
+ Options options = new Options();
+ addOptions(options);
+
+ CommandLineParser parser = new DefaultParser();
+ CommandLine cmd = parser.parse(options, args);
+
+ if (cmd.hasOption("help")) {
+ printUsageAndExit(options, 1);
+ }
+ parseCommandLine(cmd, options);
+ }
+
+ public void stop() {
+ if (this.infoServer != null) {
+ LOG.info("Stopping infoServer");
+ try {
+ this.infoServer.stop();
+ } catch (Exception ex) {
+ LOG.error("Failed to stop infoServer", ex);
+ }
+ }
+ if (pauseMonitor != null) {
+ pauseMonitor.stop();
+ }
+ if (tserver != null) {
+ tserver.stop();
+ tserver = null;
+ }
+ if (httpServer != null) {
+ try {
+ httpServer.stop();
+ httpServer = null;
+ } catch (Exception e) {
+ LOG.error("Problem encountered in shutting down HTTP server", e);
+ }
+ httpServer = null;
+ }
+ }
+
+ protected static void optionToConf(CommandLine cmd, String option, Configuration conf,
+ String destConfKey) {
+ if (cmd.hasOption(option)) {
+ String value = cmd.getOptionValue(option);
+ LOG.info("Set configuration key:" + destConfKey + " value:" + value);
+ conf.set(destConfKey, value);
+ }
+ }
+
+ /**
+ * Run without any command line arguments
+ * @return exit code
+ * @throws Exception exception
+ */
+ public int run() throws Exception {
+ return run(null);
+ }
+
+ @Override
+ public int run(String[] strings) throws Exception {
+ processOptions(strings);
+ setupParamters();
+ if (httpEnabled) {
+ setupHTTPServer();
+ } else {
+ setupServer();
+ }
+ serviceUGI.doAs(new PrivilegedAction<Object>() {
+ @Override
+ public Object run() {
+ try {
+ startInfoServer();
+ if (httpEnabled) {
+ httpServer.start();
+ httpServer.join();
+ } else {
+ tserver.serve();
+ }
+ } catch (Exception e) {
+ LOG.error(HBaseMarkers.FATAL, "Cannot run ThriftServer", e);
+
+ System.exit(-1);
+ }
+ return null;
+ }
+ });
+ return 0;
+ }
+
+ public static void main(String[] args) throws Exception {
+ LOG.info("***** STARTING service '" + ThriftServer.class.getSimpleName() + "' *****");
+ VersionInfo.logVersion();
+ final Configuration conf = HBaseConfiguration.create();
+ // for now, only time we return is on an argument error.
+ final int status = ToolRunner.run(conf, new ThriftServer(conf), args);
+ LOG.info("***** STOPPING service '" + ThriftServer.class.getSimpleName() + "' *****");
+ System.exit(status);
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftUtilities.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftUtilities.java
new file mode 100644
index 0000000..38edd98
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/ThriftUtilities.java
@@ -0,0 +1,249 @@
+/*
+ * 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.thrift;
+
+import static org.apache.hadoop.hbase.util.Bytes.getBytes;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.TreeMap;
+import org.apache.hadoop.hbase.Cell;
+import org.apache.hadoop.hbase.CellUtil;
+import org.apache.hadoop.hbase.KeyValue;
+import org.apache.hadoop.hbase.client.Append;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder;
+import org.apache.hadoop.hbase.client.Increment;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.io.compress.Compression;
+import org.apache.hadoop.hbase.regionserver.BloomType;
+import org.apache.hadoop.hbase.security.access.Permission;
+import org.apache.hadoop.hbase.thrift.generated.ColumnDescriptor;
+import org.apache.hadoop.hbase.thrift.generated.IllegalArgument;
+import org.apache.hadoop.hbase.thrift.generated.TAppend;
+import org.apache.hadoop.hbase.thrift.generated.TCell;
+import org.apache.hadoop.hbase.thrift.generated.TColumn;
+import org.apache.hadoop.hbase.thrift.generated.TIncrement;
+import org.apache.hadoop.hbase.thrift.generated.TRowResult;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.yetus.audience.InterfaceAudience;
+
+@InterfaceAudience.Private
+public final class ThriftUtilities {
+ private ThriftUtilities() {
+ }
+
+ /**
+ * This utility method creates a new Hbase HColumnDescriptor object based on a Thrift
+ * ColumnDescriptor "struct".
+ * @param in Thrift ColumnDescriptor object n * @throws IllegalArgument if the column name is
+ * empty
+ */
+ public static ColumnFamilyDescriptor colDescFromThrift(ColumnDescriptor in)
+ throws IllegalArgument {
+ Compression.Algorithm comp =
+ Compression.getCompressionAlgorithmByName(in.compression.toLowerCase(Locale.ROOT));
+ BloomType bt = BloomType.valueOf(in.bloomFilterType);
+
+ if (in.name == null || !in.name.hasRemaining()) {
+ throw new IllegalArgument("column name is empty");
+ }
+ byte[] parsedName = CellUtil.parseColumn(Bytes.getBytes(in.name))[0];
+ return ColumnFamilyDescriptorBuilder.newBuilder(parsedName).setMaxVersions(in.maxVersions)
+ .setCompressionType(comp).setInMemory(in.inMemory).setBlockCacheEnabled(in.blockCacheEnabled)
+ .setTimeToLive(in.timeToLive > 0 ? in.timeToLive : Integer.MAX_VALUE).setBloomFilterType(bt)
+ .build();
+ }
+
+ /**
+ * This utility method creates a new Thrift ColumnDescriptor "struct" based on an Hbase
+ * HColumnDescriptor object. n * Hbase HColumnDescriptor object
+ * @return Thrift ColumnDescriptor
+ */
+ public static ColumnDescriptor colDescFromHbase(ColumnFamilyDescriptor in) {
+ ColumnDescriptor col = new ColumnDescriptor();
+ col.name = ByteBuffer.wrap(Bytes.add(in.getName(), KeyValue.COLUMN_FAMILY_DELIM_ARRAY));
+ col.maxVersions = in.getMaxVersions();
+ col.compression = in.getCompressionType().toString();
+ col.inMemory = in.isInMemory();
+ col.blockCacheEnabled = in.isBlockCacheEnabled();
+ col.bloomFilterType = in.getBloomFilterType().toString();
+ col.timeToLive = in.getTimeToLive();
+ return col;
+ }
+
+ /**
+ * This utility method creates a list of Thrift TCell "struct" based on an Hbase Cell object. The
+ * empty list is returned if the input is null. n * Hbase Cell object
+ * @return Thrift TCell array
+ */
+ public static List<TCell> cellFromHBase(Cell in) {
+ List<TCell> list = new ArrayList<>(1);
+ if (in != null) {
+ list.add(new TCell(ByteBuffer.wrap(CellUtil.cloneValue(in)), in.getTimestamp()));
+ }
+ return list;
+ }
+
+ /**
+ * This utility method creates a list of Thrift TCell "struct" based on an Hbase Cell array. The
+ * empty list is returned if the input is null.
+ * @param in Hbase Cell array
+ * @return Thrift TCell array
+ */
+ public static List<TCell> cellFromHBase(Cell[] in) {
+ List<TCell> list = null;
+ if (in != null) {
+ list = new ArrayList<>(in.length);
+ for (int i = 0; i < in.length; i++) {
+ list.add(new TCell(ByteBuffer.wrap(CellUtil.cloneValue(in[i])), in[i].getTimestamp()));
+ }
+ } else {
+ list = new ArrayList<>(0);
+ }
+ return list;
+ }
+
+ /**
+ * This utility method creates a list of Thrift TRowResult "struct" based on an Hbase RowResult
+ * object. The empty list is returned if the input is null. n * Hbase RowResult object n * This
+ * boolean dictates if row data is returned in a sorted order sortColumns = True will set
+ * TRowResult's sortedColumns member which is an ArrayList of TColumn struct sortColumns = False
+ * will set TRowResult's columns member which is a map of columnName and TCell struct
+ * @return Thrift TRowResult array
+ */
+ public static List<TRowResult> rowResultFromHBase(Result[] in, boolean sortColumns) {
+ List<TRowResult> results = new ArrayList<>(in.length);
+ for (Result result_ : in) {
+ if (result_ == null || result_.isEmpty()) {
+ continue;
+ }
+
+ TRowResult result = new TRowResult();
+ result.row = ByteBuffer.wrap(result_.getRow());
+
+ if (sortColumns) {
+ result.sortedColumns = new ArrayList<>();
+ for (Cell kv : result_.rawCells()) {
+ result.sortedColumns.add(new TColumn(
+ ByteBuffer
+ .wrap(CellUtil.makeColumn(CellUtil.cloneFamily(kv), CellUtil.cloneQualifier(kv))),
+ new TCell(ByteBuffer.wrap(CellUtil.cloneValue(kv)), kv.getTimestamp())));
+ }
+ } else {
+ result.columns = new TreeMap<>();
+ for (Cell kv : result_.rawCells()) {
+ result.columns.put(
+ ByteBuffer
+ .wrap(CellUtil.makeColumn(CellUtil.cloneFamily(kv), CellUtil.cloneQualifier(kv))),
+ new TCell(ByteBuffer.wrap(CellUtil.cloneValue(kv)), kv.getTimestamp()));
+ }
+ }
+
+ results.add(result);
+ }
+
+ return results;
+ }
+
+ /**
+ * This utility method creates a list of Thrift TRowResult "struct" based on an array of Hbase
+ * RowResult objects. The empty list is returned if the input is null. n * Array of Hbase
+ * RowResult objects
+ * @return Thrift TRowResult array
+ */
+ public static List<TRowResult> rowResultFromHBase(Result[] in) {
+ return rowResultFromHBase(in, false);
+ }
+
+ public static List<TRowResult> rowResultFromHBase(Result in) {
+ Result[] result = { in };
+ return rowResultFromHBase(result);
+ }
+
+ /**
+ * From a {@link TIncrement} create an {@link Increment}.
+ * @param tincrement the Thrift version of an increment
+ * @return an increment that the {@link TIncrement} represented.
+ */
+ public static Increment incrementFromThrift(TIncrement tincrement) {
+ Increment inc = new Increment(tincrement.getRow());
+ byte[][] famAndQf = CellUtil.parseColumn(tincrement.getColumn());
+
+ if (famAndQf.length != 2) {
+ return null;
+ }
+
+ inc.addColumn(famAndQf[0], famAndQf[1], tincrement.getAmmount());
+ return inc;
+ }
+
+ /**
+ * From a {@link TAppend} create an {@link Append}.
+ * @param tappend the Thrift version of an append.
+ * @return an increment that the {@link TAppend} represented.
+ */
+ public static Append appendFromThrift(TAppend tappend) {
+ Append append = new Append(tappend.getRow());
+ List<ByteBuffer> columns = tappend.getColumns();
+ List<ByteBuffer> values = tappend.getValues();
+
+ if (columns.size() != values.size()) {
+ throw new IllegalArgumentException(
+ "Sizes of columns and values in tappend object are not matching");
+ }
+
+ int length = columns.size();
+
+ for (int i = 0; i < length; i++) {
+ byte[][] famAndQf = CellUtil.parseColumn(getBytes(columns.get(i)));
+ append.addColumn(famAndQf[0], famAndQf[1], getBytes(values.get(i)));
+ }
+ return append;
+ }
+
+ public static Permission.Action[] permissionActionsFromString(String permission_actions) {
+ Set<Permission.Action> actions = new HashSet<>();
+ for (char c : permission_actions.toCharArray()) {
+ switch (c) {
+ case 'R':
+ actions.add(Permission.Action.READ);
+ break;
+ case 'W':
+ actions.add(Permission.Action.WRITE);
+ break;
+ case 'C':
+ actions.add(Permission.Action.CREATE);
+ break;
+ case 'X':
+ actions.add(Permission.Action.EXEC);
+ break;
+ case 'A':
+ actions.add(Permission.Action.ADMIN);
+ break;
+ default:
+ break;
+ }
+ }
+ return actions.toArray(new Permission.Action[0]);
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/AlreadyExists.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/AlreadyExists.java
new file mode 100644
index 0000000..612a3ce
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/AlreadyExists.java
@@ -0,0 +1,379 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * An AlreadyExists exceptions signals that a table with the specified
+ * name already exists
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class AlreadyExists extends org.apache.thrift.TException implements org.apache.thrift.TBase<AlreadyExists, AlreadyExists._Fields>, java.io.Serializable, Cloneable, Comparable<AlreadyExists> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("AlreadyExists");
+
+ private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new AlreadyExistsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new AlreadyExistsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String message; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ MESSAGE((short)1, "message");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // MESSAGE
+ return MESSAGE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AlreadyExists.class, metaDataMap);
+ }
+
+ public AlreadyExists() {
+ }
+
+ public AlreadyExists(
+ java.lang.String message)
+ {
+ this();
+ this.message = message;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public AlreadyExists(AlreadyExists other) {
+ if (other.isSetMessage()) {
+ this.message = other.message;
+ }
+ }
+
+ public AlreadyExists deepCopy() {
+ return new AlreadyExists(this);
+ }
+
+ @Override
+ public void clear() {
+ this.message = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getMessage() {
+ return this.message;
+ }
+
+ public AlreadyExists setMessage(@org.apache.thrift.annotation.Nullable java.lang.String message) {
+ this.message = message;
+ return this;
+ }
+
+ public void unsetMessage() {
+ this.message = null;
+ }
+
+ /** Returns true if field message is set (has been assigned a value) and false otherwise */
+ public boolean isSetMessage() {
+ return this.message != null;
+ }
+
+ public void setMessageIsSet(boolean value) {
+ if (!value) {
+ this.message = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case MESSAGE:
+ if (value == null) {
+ unsetMessage();
+ } else {
+ setMessage((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MESSAGE:
+ return getMessage();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case MESSAGE:
+ return isSetMessage();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof AlreadyExists)
+ return this.equals((AlreadyExists)that);
+ return false;
+ }
+
+ public boolean equals(AlreadyExists that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_message = true && this.isSetMessage();
+ boolean that_present_message = true && that.isSetMessage();
+ if (this_present_message || that_present_message) {
+ if (!(this_present_message && that_present_message))
+ return false;
+ if (!this.message.equals(that.message))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetMessage()) ? 131071 : 524287);
+ if (isSetMessage())
+ hashCode = hashCode * 8191 + message.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(AlreadyExists other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetMessage(), other.isSetMessage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMessage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.message, other.message);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("AlreadyExists(");
+ boolean first = true;
+
+ sb.append("message:");
+ if (this.message == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.message);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class AlreadyExistsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public AlreadyExistsStandardScheme getScheme() {
+ return new AlreadyExistsStandardScheme();
+ }
+ }
+
+ private static class AlreadyExistsStandardScheme extends org.apache.thrift.scheme.StandardScheme<AlreadyExists> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, AlreadyExists struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // MESSAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, AlreadyExists struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.message != null) {
+ oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+ oprot.writeString(struct.message);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class AlreadyExistsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public AlreadyExistsTupleScheme getScheme() {
+ return new AlreadyExistsTupleScheme();
+ }
+ }
+
+ private static class AlreadyExistsTupleScheme extends org.apache.thrift.scheme.TupleScheme<AlreadyExists> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, AlreadyExists struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetMessage()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetMessage()) {
+ oprot.writeString(struct.message);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, AlreadyExists struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/BatchMutation.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/BatchMutation.java
new file mode 100644
index 0000000..e1ec71d
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/BatchMutation.java
@@ -0,0 +1,551 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * A BatchMutation object is used to apply a number of Mutations to a single row.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class BatchMutation implements org.apache.thrift.TBase<BatchMutation, BatchMutation._Fields>, java.io.Serializable, Cloneable, Comparable<BatchMutation> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("BatchMutation");
+
+ 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)1);
+ 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)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new BatchMutationStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new BatchMutationTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<Mutation> mutations; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ MUTATIONS((short)2, "mutations");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // MUTATIONS
+ return MUTATIONS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(BatchMutation.class, metaDataMap);
+ }
+
+ public BatchMutation() {
+ }
+
+ public BatchMutation(
+ java.nio.ByteBuffer row,
+ java.util.List<Mutation> mutations)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.mutations = mutations;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public BatchMutation(BatchMutation other) {
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetMutations()) {
+ java.util.List<Mutation> __this__mutations = new java.util.ArrayList<Mutation>(other.mutations.size());
+ for (Mutation other_element : other.mutations) {
+ __this__mutations.add(new Mutation(other_element));
+ }
+ this.mutations = __this__mutations;
+ }
+ }
+
+ public BatchMutation deepCopy() {
+ return new BatchMutation(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.mutations = null;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public BatchMutation setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public BatchMutation setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getMutationsSize() {
+ return (this.mutations == null) ? 0 : this.mutations.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<Mutation> getMutationsIterator() {
+ return (this.mutations == null) ? null : this.mutations.iterator();
+ }
+
+ public void addToMutations(Mutation elem) {
+ if (this.mutations == null) {
+ this.mutations = new java.util.ArrayList<Mutation>();
+ }
+ this.mutations.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<Mutation> getMutations() {
+ return this.mutations;
+ }
+
+ public BatchMutation setMutations(@org.apache.thrift.annotation.Nullable java.util.List<Mutation> mutations) {
+ this.mutations = mutations;
+ return this;
+ }
+
+ public void unsetMutations() {
+ this.mutations = null;
+ }
+
+ /** Returns true if field mutations is set (has been assigned a value) and false otherwise */
+ public boolean isSetMutations() {
+ return this.mutations != null;
+ }
+
+ public void setMutationsIsSet(boolean value) {
+ if (!value) {
+ this.mutations = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case MUTATIONS:
+ if (value == null) {
+ unsetMutations();
+ } else {
+ setMutations((java.util.List<Mutation>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case MUTATIONS:
+ return getMutations();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case MUTATIONS:
+ return isSetMutations();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof BatchMutation)
+ return this.equals((BatchMutation)that);
+ return false;
+ }
+
+ public boolean equals(BatchMutation that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_mutations = true && this.isSetMutations();
+ boolean that_present_mutations = true && that.isSetMutations();
+ if (this_present_mutations || that_present_mutations) {
+ if (!(this_present_mutations && that_present_mutations))
+ return false;
+ if (!this.mutations.equals(that.mutations))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetMutations()) ? 131071 : 524287);
+ if (isSetMutations())
+ hashCode = hashCode * 8191 + mutations.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(BatchMutation other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMutations(), other.isSetMutations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMutations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutations, other.mutations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("BatchMutation(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("mutations:");
+ if (this.mutations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.mutations);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class BatchMutationStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public BatchMutationStandardScheme getScheme() {
+ return new BatchMutationStandardScheme();
+ }
+ }
+
+ private static class BatchMutationStandardScheme extends org.apache.thrift.scheme.StandardScheme<BatchMutation> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, BatchMutation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // MUTATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list0 = iprot.readListBegin();
+ struct.mutations = new java.util.ArrayList<Mutation>(_list0.size);
+ @org.apache.thrift.annotation.Nullable Mutation _elem1;
+ for (int _i2 = 0; _i2 < _list0.size; ++_i2)
+ {
+ _elem1 = new Mutation();
+ _elem1.read(iprot);
+ struct.mutations.add(_elem1);
+ }
+ iprot.readListEnd();
+ }
+ struct.setMutationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, BatchMutation struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.mutations != null) {
+ oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mutations.size()));
+ for (Mutation _iter3 : struct.mutations)
+ {
+ _iter3.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class BatchMutationTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public BatchMutationTupleScheme getScheme() {
+ return new BatchMutationTupleScheme();
+ }
+ }
+
+ private static class BatchMutationTupleScheme extends org.apache.thrift.scheme.TupleScheme<BatchMutation> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, BatchMutation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRow()) {
+ optionals.set(0);
+ }
+ if (struct.isSetMutations()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetMutations()) {
+ {
+ oprot.writeI32(struct.mutations.size());
+ for (Mutation _iter4 : struct.mutations)
+ {
+ _iter4.write(oprot);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, BatchMutation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list5 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.mutations = new java.util.ArrayList<Mutation>(_list5.size);
+ @org.apache.thrift.annotation.Nullable Mutation _elem6;
+ for (int _i7 = 0; _i7 < _list5.size; ++_i7)
+ {
+ _elem6 = new Mutation();
+ _elem6.read(iprot);
+ struct.mutations.add(_elem6);
+ }
+ }
+ struct.setMutationsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/ColumnDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/ColumnDescriptor.java
new file mode 100644
index 0000000..58cdc9d
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/ColumnDescriptor.java
@@ -0,0 +1,1201 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * An HColumnDescriptor contains information about a column family
+ * such as the number of versions, compression settings, etc. It is
+ * used as input when creating a table or adding a column.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class ColumnDescriptor implements org.apache.thrift.TBase<ColumnDescriptor, ColumnDescriptor._Fields>, java.io.Serializable, Cloneable, Comparable<ColumnDescriptor> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ColumnDescriptor");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField MAX_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("maxVersions", org.apache.thrift.protocol.TType.I32, (short)2);
+ private static final org.apache.thrift.protocol.TField COMPRESSION_FIELD_DESC = new org.apache.thrift.protocol.TField("compression", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField IN_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("inMemory", org.apache.thrift.protocol.TType.BOOL, (short)4);
+ private static final org.apache.thrift.protocol.TField BLOOM_FILTER_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomFilterType", org.apache.thrift.protocol.TType.STRING, (short)5);
+ private static final org.apache.thrift.protocol.TField BLOOM_FILTER_VECTOR_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomFilterVectorSize", org.apache.thrift.protocol.TType.I32, (short)6);
+ private static final org.apache.thrift.protocol.TField BLOOM_FILTER_NB_HASHES_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomFilterNbHashes", org.apache.thrift.protocol.TType.I32, (short)7);
+ private static final org.apache.thrift.protocol.TField BLOCK_CACHE_ENABLED_FIELD_DESC = new org.apache.thrift.protocol.TField("blockCacheEnabled", org.apache.thrift.protocol.TType.BOOL, (short)8);
+ private static final org.apache.thrift.protocol.TField TIME_TO_LIVE_FIELD_DESC = new org.apache.thrift.protocol.TField("timeToLive", org.apache.thrift.protocol.TType.I32, (short)9);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new ColumnDescriptorStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new ColumnDescriptorTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer name; // required
+ public int maxVersions; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String compression; // required
+ public boolean inMemory; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String bloomFilterType; // required
+ public int bloomFilterVectorSize; // required
+ public int bloomFilterNbHashes; // required
+ public boolean blockCacheEnabled; // required
+ public int timeToLive; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ NAME((short)1, "name"),
+ MAX_VERSIONS((short)2, "maxVersions"),
+ COMPRESSION((short)3, "compression"),
+ IN_MEMORY((short)4, "inMemory"),
+ BLOOM_FILTER_TYPE((short)5, "bloomFilterType"),
+ BLOOM_FILTER_VECTOR_SIZE((short)6, "bloomFilterVectorSize"),
+ BLOOM_FILTER_NB_HASHES((short)7, "bloomFilterNbHashes"),
+ BLOCK_CACHE_ENABLED((short)8, "blockCacheEnabled"),
+ TIME_TO_LIVE((short)9, "timeToLive");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ case 2: // MAX_VERSIONS
+ return MAX_VERSIONS;
+ case 3: // COMPRESSION
+ return COMPRESSION;
+ case 4: // IN_MEMORY
+ return IN_MEMORY;
+ case 5: // BLOOM_FILTER_TYPE
+ return BLOOM_FILTER_TYPE;
+ case 6: // BLOOM_FILTER_VECTOR_SIZE
+ return BLOOM_FILTER_VECTOR_SIZE;
+ case 7: // BLOOM_FILTER_NB_HASHES
+ return BLOOM_FILTER_NB_HASHES;
+ case 8: // BLOCK_CACHE_ENABLED
+ return BLOCK_CACHE_ENABLED;
+ case 9: // TIME_TO_LIVE
+ return TIME_TO_LIVE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __MAXVERSIONS_ISSET_ID = 0;
+ private static final int __INMEMORY_ISSET_ID = 1;
+ private static final int __BLOOMFILTERVECTORSIZE_ISSET_ID = 2;
+ private static final int __BLOOMFILTERNBHASHES_ISSET_ID = 3;
+ private static final int __BLOCKCACHEENABLED_ISSET_ID = 4;
+ private static final int __TIMETOLIVE_ISSET_ID = 5;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
+ tmpMap.put(_Fields.MAX_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("maxVersions", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.COMPRESSION, new org.apache.thrift.meta_data.FieldMetaData("compression", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.IN_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("inMemory", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.BLOOM_FILTER_TYPE, new org.apache.thrift.meta_data.FieldMetaData("bloomFilterType", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.BLOOM_FILTER_VECTOR_SIZE, new org.apache.thrift.meta_data.FieldMetaData("bloomFilterVectorSize", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.BLOOM_FILTER_NB_HASHES, new org.apache.thrift.meta_data.FieldMetaData("bloomFilterNbHashes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.BLOCK_CACHE_ENABLED, new org.apache.thrift.meta_data.FieldMetaData("blockCacheEnabled", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.TIME_TO_LIVE, new org.apache.thrift.meta_data.FieldMetaData("timeToLive", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ColumnDescriptor.class, metaDataMap);
+ }
+
+ public ColumnDescriptor() {
+ this.maxVersions = 3;
+
+ this.compression = "NONE";
+
+ this.inMemory = false;
+
+ this.bloomFilterType = "NONE";
+
+ this.bloomFilterVectorSize = 0;
+
+ this.bloomFilterNbHashes = 0;
+
+ this.blockCacheEnabled = false;
+
+ this.timeToLive = 2147483647;
+
+ }
+
+ public ColumnDescriptor(
+ java.nio.ByteBuffer name,
+ int maxVersions,
+ java.lang.String compression,
+ boolean inMemory,
+ java.lang.String bloomFilterType,
+ int bloomFilterVectorSize,
+ int bloomFilterNbHashes,
+ boolean blockCacheEnabled,
+ int timeToLive)
+ {
+ this();
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(name);
+ this.maxVersions = maxVersions;
+ setMaxVersionsIsSet(true);
+ this.compression = compression;
+ this.inMemory = inMemory;
+ setInMemoryIsSet(true);
+ this.bloomFilterType = bloomFilterType;
+ this.bloomFilterVectorSize = bloomFilterVectorSize;
+ setBloomFilterVectorSizeIsSet(true);
+ this.bloomFilterNbHashes = bloomFilterNbHashes;
+ setBloomFilterNbHashesIsSet(true);
+ this.blockCacheEnabled = blockCacheEnabled;
+ setBlockCacheEnabledIsSet(true);
+ this.timeToLive = timeToLive;
+ setTimeToLiveIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public ColumnDescriptor(ColumnDescriptor other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetName()) {
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(other.name);
+ }
+ this.maxVersions = other.maxVersions;
+ if (other.isSetCompression()) {
+ this.compression = other.compression;
+ }
+ this.inMemory = other.inMemory;
+ if (other.isSetBloomFilterType()) {
+ this.bloomFilterType = other.bloomFilterType;
+ }
+ this.bloomFilterVectorSize = other.bloomFilterVectorSize;
+ this.bloomFilterNbHashes = other.bloomFilterNbHashes;
+ this.blockCacheEnabled = other.blockCacheEnabled;
+ this.timeToLive = other.timeToLive;
+ }
+
+ public ColumnDescriptor deepCopy() {
+ return new ColumnDescriptor(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ this.maxVersions = 3;
+
+ this.compression = "NONE";
+
+ this.inMemory = false;
+
+ this.bloomFilterType = "NONE";
+
+ this.bloomFilterVectorSize = 0;
+
+ this.bloomFilterNbHashes = 0;
+
+ this.blockCacheEnabled = false;
+
+ this.timeToLive = 2147483647;
+
+ }
+
+ public byte[] getName() {
+ setName(org.apache.thrift.TBaseHelper.rightSize(name));
+ return name == null ? null : name.array();
+ }
+
+ public java.nio.ByteBuffer bufferForName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(name);
+ }
+
+ public ColumnDescriptor setName(byte[] name) {
+ this.name = name == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(name.clone());
+ return this;
+ }
+
+ public ColumnDescriptor setName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer name) {
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(name);
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public int getMaxVersions() {
+ return this.maxVersions;
+ }
+
+ public ColumnDescriptor setMaxVersions(int maxVersions) {
+ this.maxVersions = maxVersions;
+ setMaxVersionsIsSet(true);
+ return this;
+ }
+
+ public void unsetMaxVersions() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ /** Returns true if field maxVersions is set (has been assigned a value) and false otherwise */
+ public boolean isSetMaxVersions() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ public void setMaxVersionsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getCompression() {
+ return this.compression;
+ }
+
+ public ColumnDescriptor setCompression(@org.apache.thrift.annotation.Nullable java.lang.String compression) {
+ this.compression = compression;
+ return this;
+ }
+
+ public void unsetCompression() {
+ this.compression = null;
+ }
+
+ /** Returns true if field compression is set (has been assigned a value) and false otherwise */
+ public boolean isSetCompression() {
+ return this.compression != null;
+ }
+
+ public void setCompressionIsSet(boolean value) {
+ if (!value) {
+ this.compression = null;
+ }
+ }
+
+ public boolean isInMemory() {
+ return this.inMemory;
+ }
+
+ public ColumnDescriptor setInMemory(boolean inMemory) {
+ this.inMemory = inMemory;
+ setInMemoryIsSet(true);
+ return this;
+ }
+
+ public void unsetInMemory() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __INMEMORY_ISSET_ID);
+ }
+
+ /** Returns true if field inMemory is set (has been assigned a value) and false otherwise */
+ public boolean isSetInMemory() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __INMEMORY_ISSET_ID);
+ }
+
+ public void setInMemoryIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __INMEMORY_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getBloomFilterType() {
+ return this.bloomFilterType;
+ }
+
+ public ColumnDescriptor setBloomFilterType(@org.apache.thrift.annotation.Nullable java.lang.String bloomFilterType) {
+ this.bloomFilterType = bloomFilterType;
+ return this;
+ }
+
+ public void unsetBloomFilterType() {
+ this.bloomFilterType = null;
+ }
+
+ /** Returns true if field bloomFilterType is set (has been assigned a value) and false otherwise */
+ public boolean isSetBloomFilterType() {
+ return this.bloomFilterType != null;
+ }
+
+ public void setBloomFilterTypeIsSet(boolean value) {
+ if (!value) {
+ this.bloomFilterType = null;
+ }
+ }
+
+ public int getBloomFilterVectorSize() {
+ return this.bloomFilterVectorSize;
+ }
+
+ public ColumnDescriptor setBloomFilterVectorSize(int bloomFilterVectorSize) {
+ this.bloomFilterVectorSize = bloomFilterVectorSize;
+ setBloomFilterVectorSizeIsSet(true);
+ return this;
+ }
+
+ public void unsetBloomFilterVectorSize() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BLOOMFILTERVECTORSIZE_ISSET_ID);
+ }
+
+ /** Returns true if field bloomFilterVectorSize is set (has been assigned a value) and false otherwise */
+ public boolean isSetBloomFilterVectorSize() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BLOOMFILTERVECTORSIZE_ISSET_ID);
+ }
+
+ public void setBloomFilterVectorSizeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BLOOMFILTERVECTORSIZE_ISSET_ID, value);
+ }
+
+ public int getBloomFilterNbHashes() {
+ return this.bloomFilterNbHashes;
+ }
+
+ public ColumnDescriptor setBloomFilterNbHashes(int bloomFilterNbHashes) {
+ this.bloomFilterNbHashes = bloomFilterNbHashes;
+ setBloomFilterNbHashesIsSet(true);
+ return this;
+ }
+
+ public void unsetBloomFilterNbHashes() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BLOOMFILTERNBHASHES_ISSET_ID);
+ }
+
+ /** Returns true if field bloomFilterNbHashes is set (has been assigned a value) and false otherwise */
+ public boolean isSetBloomFilterNbHashes() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BLOOMFILTERNBHASHES_ISSET_ID);
+ }
+
+ public void setBloomFilterNbHashesIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BLOOMFILTERNBHASHES_ISSET_ID, value);
+ }
+
+ public boolean isBlockCacheEnabled() {
+ return this.blockCacheEnabled;
+ }
+
+ public ColumnDescriptor setBlockCacheEnabled(boolean blockCacheEnabled) {
+ this.blockCacheEnabled = blockCacheEnabled;
+ setBlockCacheEnabledIsSet(true);
+ return this;
+ }
+
+ public void unsetBlockCacheEnabled() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID);
+ }
+
+ /** Returns true if field blockCacheEnabled is set (has been assigned a value) and false otherwise */
+ public boolean isSetBlockCacheEnabled() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID);
+ }
+
+ public void setBlockCacheEnabledIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID, value);
+ }
+
+ public int getTimeToLive() {
+ return this.timeToLive;
+ }
+
+ public ColumnDescriptor setTimeToLive(int timeToLive) {
+ this.timeToLive = timeToLive;
+ setTimeToLiveIsSet(true);
+ return this;
+ }
+
+ public void unsetTimeToLive() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID);
+ }
+
+ /** Returns true if field timeToLive is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimeToLive() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID);
+ }
+
+ public void setTimeToLiveIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ if (value instanceof byte[]) {
+ setName((byte[])value);
+ } else {
+ setName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case MAX_VERSIONS:
+ if (value == null) {
+ unsetMaxVersions();
+ } else {
+ setMaxVersions((java.lang.Integer)value);
+ }
+ break;
+
+ case COMPRESSION:
+ if (value == null) {
+ unsetCompression();
+ } else {
+ setCompression((java.lang.String)value);
+ }
+ break;
+
+ case IN_MEMORY:
+ if (value == null) {
+ unsetInMemory();
+ } else {
+ setInMemory((java.lang.Boolean)value);
+ }
+ break;
+
+ case BLOOM_FILTER_TYPE:
+ if (value == null) {
+ unsetBloomFilterType();
+ } else {
+ setBloomFilterType((java.lang.String)value);
+ }
+ break;
+
+ case BLOOM_FILTER_VECTOR_SIZE:
+ if (value == null) {
+ unsetBloomFilterVectorSize();
+ } else {
+ setBloomFilterVectorSize((java.lang.Integer)value);
+ }
+ break;
+
+ case BLOOM_FILTER_NB_HASHES:
+ if (value == null) {
+ unsetBloomFilterNbHashes();
+ } else {
+ setBloomFilterNbHashes((java.lang.Integer)value);
+ }
+ break;
+
+ case BLOCK_CACHE_ENABLED:
+ if (value == null) {
+ unsetBlockCacheEnabled();
+ } else {
+ setBlockCacheEnabled((java.lang.Boolean)value);
+ }
+ break;
+
+ case TIME_TO_LIVE:
+ if (value == null) {
+ unsetTimeToLive();
+ } else {
+ setTimeToLive((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ case MAX_VERSIONS:
+ return getMaxVersions();
+
+ case COMPRESSION:
+ return getCompression();
+
+ case IN_MEMORY:
+ return isInMemory();
+
+ case BLOOM_FILTER_TYPE:
+ return getBloomFilterType();
+
+ case BLOOM_FILTER_VECTOR_SIZE:
+ return getBloomFilterVectorSize();
+
+ case BLOOM_FILTER_NB_HASHES:
+ return getBloomFilterNbHashes();
+
+ case BLOCK_CACHE_ENABLED:
+ return isBlockCacheEnabled();
+
+ case TIME_TO_LIVE:
+ return getTimeToLive();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ case MAX_VERSIONS:
+ return isSetMaxVersions();
+ case COMPRESSION:
+ return isSetCompression();
+ case IN_MEMORY:
+ return isSetInMemory();
+ case BLOOM_FILTER_TYPE:
+ return isSetBloomFilterType();
+ case BLOOM_FILTER_VECTOR_SIZE:
+ return isSetBloomFilterVectorSize();
+ case BLOOM_FILTER_NB_HASHES:
+ return isSetBloomFilterNbHashes();
+ case BLOCK_CACHE_ENABLED:
+ return isSetBlockCacheEnabled();
+ case TIME_TO_LIVE:
+ return isSetTimeToLive();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof ColumnDescriptor)
+ return this.equals((ColumnDescriptor)that);
+ return false;
+ }
+
+ public boolean equals(ColumnDescriptor that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ boolean this_present_maxVersions = true;
+ boolean that_present_maxVersions = true;
+ if (this_present_maxVersions || that_present_maxVersions) {
+ if (!(this_present_maxVersions && that_present_maxVersions))
+ return false;
+ if (this.maxVersions != that.maxVersions)
+ return false;
+ }
+
+ boolean this_present_compression = true && this.isSetCompression();
+ boolean that_present_compression = true && that.isSetCompression();
+ if (this_present_compression || that_present_compression) {
+ if (!(this_present_compression && that_present_compression))
+ return false;
+ if (!this.compression.equals(that.compression))
+ return false;
+ }
+
+ boolean this_present_inMemory = true;
+ boolean that_present_inMemory = true;
+ if (this_present_inMemory || that_present_inMemory) {
+ if (!(this_present_inMemory && that_present_inMemory))
+ return false;
+ if (this.inMemory != that.inMemory)
+ return false;
+ }
+
+ boolean this_present_bloomFilterType = true && this.isSetBloomFilterType();
+ boolean that_present_bloomFilterType = true && that.isSetBloomFilterType();
+ if (this_present_bloomFilterType || that_present_bloomFilterType) {
+ if (!(this_present_bloomFilterType && that_present_bloomFilterType))
+ return false;
+ if (!this.bloomFilterType.equals(that.bloomFilterType))
+ return false;
+ }
+
+ boolean this_present_bloomFilterVectorSize = true;
+ boolean that_present_bloomFilterVectorSize = true;
+ if (this_present_bloomFilterVectorSize || that_present_bloomFilterVectorSize) {
+ if (!(this_present_bloomFilterVectorSize && that_present_bloomFilterVectorSize))
+ return false;
+ if (this.bloomFilterVectorSize != that.bloomFilterVectorSize)
+ return false;
+ }
+
+ boolean this_present_bloomFilterNbHashes = true;
+ boolean that_present_bloomFilterNbHashes = true;
+ if (this_present_bloomFilterNbHashes || that_present_bloomFilterNbHashes) {
+ if (!(this_present_bloomFilterNbHashes && that_present_bloomFilterNbHashes))
+ return false;
+ if (this.bloomFilterNbHashes != that.bloomFilterNbHashes)
+ return false;
+ }
+
+ boolean this_present_blockCacheEnabled = true;
+ boolean that_present_blockCacheEnabled = true;
+ if (this_present_blockCacheEnabled || that_present_blockCacheEnabled) {
+ if (!(this_present_blockCacheEnabled && that_present_blockCacheEnabled))
+ return false;
+ if (this.blockCacheEnabled != that.blockCacheEnabled)
+ return false;
+ }
+
+ boolean this_present_timeToLive = true;
+ boolean that_present_timeToLive = true;
+ if (this_present_timeToLive || that_present_timeToLive) {
+ if (!(this_present_timeToLive && that_present_timeToLive))
+ return false;
+ if (this.timeToLive != that.timeToLive)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ hashCode = hashCode * 8191 + maxVersions;
+
+ hashCode = hashCode * 8191 + ((isSetCompression()) ? 131071 : 524287);
+ if (isSetCompression())
+ hashCode = hashCode * 8191 + compression.hashCode();
+
+ hashCode = hashCode * 8191 + ((inMemory) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetBloomFilterType()) ? 131071 : 524287);
+ if (isSetBloomFilterType())
+ hashCode = hashCode * 8191 + bloomFilterType.hashCode();
+
+ hashCode = hashCode * 8191 + bloomFilterVectorSize;
+
+ hashCode = hashCode * 8191 + bloomFilterNbHashes;
+
+ hashCode = hashCode * 8191 + ((blockCacheEnabled) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + timeToLive;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(ColumnDescriptor other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMaxVersions(), other.isSetMaxVersions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMaxVersions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxVersions, other.maxVersions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCompression(), other.isSetCompression());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCompression()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.compression, other.compression);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetInMemory(), other.isSetInMemory());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetInMemory()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.inMemory, other.inMemory);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBloomFilterType(), other.isSetBloomFilterType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBloomFilterType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomFilterType, other.bloomFilterType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBloomFilterVectorSize(), other.isSetBloomFilterVectorSize());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBloomFilterVectorSize()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomFilterVectorSize, other.bloomFilterVectorSize);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBloomFilterNbHashes(), other.isSetBloomFilterNbHashes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBloomFilterNbHashes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomFilterNbHashes, other.bloomFilterNbHashes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBlockCacheEnabled(), other.isSetBlockCacheEnabled());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBlockCacheEnabled()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.blockCacheEnabled, other.blockCacheEnabled);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimeToLive(), other.isSetTimeToLive());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimeToLive()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeToLive, other.timeToLive);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("ColumnDescriptor(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.name, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("maxVersions:");
+ sb.append(this.maxVersions);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("compression:");
+ if (this.compression == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.compression);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("inMemory:");
+ sb.append(this.inMemory);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("bloomFilterType:");
+ if (this.bloomFilterType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.bloomFilterType);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("bloomFilterVectorSize:");
+ sb.append(this.bloomFilterVectorSize);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("bloomFilterNbHashes:");
+ sb.append(this.bloomFilterNbHashes);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("blockCacheEnabled:");
+ sb.append(this.blockCacheEnabled);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timeToLive:");
+ sb.append(this.timeToLive);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class ColumnDescriptorStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public ColumnDescriptorStandardScheme getScheme() {
+ return new ColumnDescriptorStandardScheme();
+ }
+ }
+
+ private static class ColumnDescriptorStandardScheme extends org.apache.thrift.scheme.StandardScheme<ColumnDescriptor> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, ColumnDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readBinary();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // MAX_VERSIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COMPRESSION
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.compression = iprot.readString();
+ struct.setCompressionIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // IN_MEMORY
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.inMemory = iprot.readBool();
+ struct.setInMemoryIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // BLOOM_FILTER_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.bloomFilterType = iprot.readString();
+ struct.setBloomFilterTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // BLOOM_FILTER_VECTOR_SIZE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.bloomFilterVectorSize = iprot.readI32();
+ struct.setBloomFilterVectorSizeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // BLOOM_FILTER_NB_HASHES
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.bloomFilterNbHashes = iprot.readI32();
+ struct.setBloomFilterNbHashesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 8: // BLOCK_CACHE_ENABLED
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.blockCacheEnabled = iprot.readBool();
+ struct.setBlockCacheEnabledIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 9: // TIME_TO_LIVE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.timeToLive = iprot.readI32();
+ struct.setTimeToLiveIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, ColumnDescriptor struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeBinary(struct.name);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
+ oprot.writeI32(struct.maxVersions);
+ oprot.writeFieldEnd();
+ if (struct.compression != null) {
+ oprot.writeFieldBegin(COMPRESSION_FIELD_DESC);
+ oprot.writeString(struct.compression);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(IN_MEMORY_FIELD_DESC);
+ oprot.writeBool(struct.inMemory);
+ oprot.writeFieldEnd();
+ if (struct.bloomFilterType != null) {
+ oprot.writeFieldBegin(BLOOM_FILTER_TYPE_FIELD_DESC);
+ oprot.writeString(struct.bloomFilterType);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(BLOOM_FILTER_VECTOR_SIZE_FIELD_DESC);
+ oprot.writeI32(struct.bloomFilterVectorSize);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(BLOOM_FILTER_NB_HASHES_FIELD_DESC);
+ oprot.writeI32(struct.bloomFilterNbHashes);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(BLOCK_CACHE_ENABLED_FIELD_DESC);
+ oprot.writeBool(struct.blockCacheEnabled);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(TIME_TO_LIVE_FIELD_DESC);
+ oprot.writeI32(struct.timeToLive);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class ColumnDescriptorTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public ColumnDescriptorTupleScheme getScheme() {
+ return new ColumnDescriptorTupleScheme();
+ }
+ }
+
+ private static class ColumnDescriptorTupleScheme extends org.apache.thrift.scheme.TupleScheme<ColumnDescriptor> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, ColumnDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetMaxVersions()) {
+ optionals.set(1);
+ }
+ if (struct.isSetCompression()) {
+ optionals.set(2);
+ }
+ if (struct.isSetInMemory()) {
+ optionals.set(3);
+ }
+ if (struct.isSetBloomFilterType()) {
+ optionals.set(4);
+ }
+ if (struct.isSetBloomFilterVectorSize()) {
+ optionals.set(5);
+ }
+ if (struct.isSetBloomFilterNbHashes()) {
+ optionals.set(6);
+ }
+ if (struct.isSetBlockCacheEnabled()) {
+ optionals.set(7);
+ }
+ if (struct.isSetTimeToLive()) {
+ optionals.set(8);
+ }
+ oprot.writeBitSet(optionals, 9);
+ if (struct.isSetName()) {
+ oprot.writeBinary(struct.name);
+ }
+ if (struct.isSetMaxVersions()) {
+ oprot.writeI32(struct.maxVersions);
+ }
+ if (struct.isSetCompression()) {
+ oprot.writeString(struct.compression);
+ }
+ if (struct.isSetInMemory()) {
+ oprot.writeBool(struct.inMemory);
+ }
+ if (struct.isSetBloomFilterType()) {
+ oprot.writeString(struct.bloomFilterType);
+ }
+ if (struct.isSetBloomFilterVectorSize()) {
+ oprot.writeI32(struct.bloomFilterVectorSize);
+ }
+ if (struct.isSetBloomFilterNbHashes()) {
+ oprot.writeI32(struct.bloomFilterNbHashes);
+ }
+ if (struct.isSetBlockCacheEnabled()) {
+ oprot.writeBool(struct.blockCacheEnabled);
+ }
+ if (struct.isSetTimeToLive()) {
+ oprot.writeI32(struct.timeToLive);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, ColumnDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(9);
+ if (incoming.get(0)) {
+ struct.name = iprot.readBinary();
+ struct.setNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.compression = iprot.readString();
+ struct.setCompressionIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.inMemory = iprot.readBool();
+ struct.setInMemoryIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.bloomFilterType = iprot.readString();
+ struct.setBloomFilterTypeIsSet(true);
+ }
+ if (incoming.get(5)) {
+ struct.bloomFilterVectorSize = iprot.readI32();
+ struct.setBloomFilterVectorSizeIsSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.bloomFilterNbHashes = iprot.readI32();
+ struct.setBloomFilterNbHashesIsSet(true);
+ }
+ if (incoming.get(7)) {
+ struct.blockCacheEnabled = iprot.readBool();
+ struct.setBlockCacheEnabledIsSet(true);
+ }
+ if (incoming.get(8)) {
+ struct.timeToLive = iprot.readI32();
+ struct.setTimeToLiveIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java
new file mode 100644
index 0000000..43bc7fb
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java
@@ -0,0 +1,64110 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-10-05")
+public class Hbase {
+
+ public interface Iface {
+
+ /**
+ * Brings a table on-line (enables it)
+ *
+ * @param tableName name of the table
+ */
+ public void enableTable(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Disables a table (takes it off-line) If it is being served, the master
+ * will tell the servers to stop serving it.
+ *
+ * @param tableName name of the table
+ */
+ public void disableTable(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * @return true if table is on-line
+ *
+ * @param tableName name of the table to check
+ */
+ public boolean isTableEnabled(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException;
+
+ public void compact(java.nio.ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException;
+
+ public void majorCompact(java.nio.ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * List all the userspace tables.
+ *
+ * @return returns a list of names
+ */
+ public java.util.List<java.nio.ByteBuffer> getTableNames() throws IOError, org.apache.thrift.TException;
+
+ /**
+ * List all the userspace tables and their enabled or disabled flags.
+ *
+ * @return list of tables with is enabled flags
+ */
+ public java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> getTableNamesWithIsTableEnabled() throws IOError, org.apache.thrift.TException;
+
+ /**
+ * List all the column families assoicated with a table.
+ *
+ * @return list of column family descriptors
+ *
+ * @param tableName table name
+ */
+ public java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> getColumnDescriptors(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * List the regions associated with a table.
+ *
+ * @return list of region descriptors
+ *
+ * @param tableName table name
+ */
+ public java.util.List<TRegionInfo> getTableRegions(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Create a table with the specified column families. The name
+ * field for each ColumnDescriptor must be set and must end in a
+ * colon (:). All other fields are optional and will get default
+ * values if not explicitly specified.
+ *
+ * @throws IllegalArgument if an input parameter is invalid
+ *
+ * @throws AlreadyExists if the table name already exists
+ *
+ * @param tableName name of table to create
+ *
+ * @param columnFamilies list of column family descriptors
+ */
+ public void createTable(java.nio.ByteBuffer tableName, java.util.List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException;
+
+ /**
+ * Deletes a table
+ *
+ * @throws IOError if table doesn't exist on server or there was some other
+ * problem
+ *
+ * @param tableName name of table to delete
+ */
+ public void deleteTable(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get a single TCell for the specified table, row, and column at the
+ * latest timestamp. Returns an empty list if no such value exists.
+ *
+ * @return value for specified row/column
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param column column name
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TCell> get(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get the specified number of versions for the specified table,
+ * row, and column.
+ *
+ * @return list of cells for specified row/column
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param column column name
+ *
+ * @param numVersions number of versions to retrieve
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TCell> getVer(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get the specified number of versions for the specified table,
+ * row, and column. Only versions less than or equal to the specified
+ * timestamp will be returned.
+ *
+ * @return list of cells for specified row/column
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param column column name
+ *
+ * @param timestamp timestamp
+ *
+ * @param numVersions number of versions to retrieve
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TCell> getVerTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get all the data for the specified table and row at the latest
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get the specified columns for the specified table and row at the latest
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param columns List of columns to return, null for all columns
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRowWithColumns(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get all the data for the specified table and row at the specified
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName name of the table
+ *
+ * @param row row key
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get the specified columns for the specified table and row at the specified
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param columns List of columns to return, null for all columns
+ *
+ * @param timestamp
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRowWithColumnsTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get all the data for the specified table and rows at the latest
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ *
+ * @param tableName name of table
+ *
+ * @param rows row keys
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRows(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get the specified columns for the specified table and rows at the latest
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ *
+ * @param tableName name of table
+ *
+ * @param rows row keys
+ *
+ * @param columns List of columns to return, null for all columns
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRowsWithColumns(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get all the data for the specified table and rows at the specified
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ *
+ * @param tableName name of the table
+ *
+ * @param rows row keys
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRowsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get the specified columns for the specified table and rows at the specified
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ *
+ * @param tableName name of table
+ *
+ * @param rows row keys
+ *
+ * @param columns List of columns to return, null for all columns
+ *
+ * @param timestamp
+ * @param attributes Get attributes
+ */
+ public java.util.List<TRowResult> getRowsWithColumnsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Apply a series of mutations (updates/deletes) to a row in a
+ * single transaction. If an exception is thrown, then the
+ * transaction is aborted. Default current timestamp is used, and
+ * all entries will have an identical timestamp.
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param mutations list of mutation commands
+ *
+ * @param attributes Mutation attributes
+ */
+ public void mutateRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Apply a series of mutations (updates/deletes) to a row in a
+ * single transaction. If an exception is thrown, then the
+ * transaction is aborted. The specified timestamp is used, and
+ * all entries will have an identical timestamp.
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param mutations list of mutation commands
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Mutation attributes
+ */
+ public void mutateRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Apply a series of batches (each a series of mutations on a single row)
+ * in a single transaction. If an exception is thrown, then the
+ * transaction is aborted. Default current timestamp is used, and
+ * all entries will have an identical timestamp.
+ *
+ * @param tableName name of table
+ *
+ * @param rowBatches list of row batches
+ *
+ * @param attributes Mutation attributes
+ */
+ public void mutateRows(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Apply a series of batches (each a series of mutations on a single row)
+ * in a single transaction. If an exception is thrown, then the
+ * transaction is aborted. The specified timestamp is used, and
+ * all entries will have an identical timestamp.
+ *
+ * @param tableName name of table
+ *
+ * @param rowBatches list of row batches
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Mutation attributes
+ */
+ public void mutateRowsTs(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Atomically increment the column value specified. Returns the next value post increment.
+ *
+ * @param tableName name of table
+ *
+ * @param row row to increment
+ *
+ * @param column name of column
+ *
+ * @param value amount to increment by
+ */
+ public long atomicIncrement(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long value) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Delete all cells that match the passed row and column.
+ *
+ * @param tableName name of table
+ *
+ * @param row Row to update
+ *
+ * @param column name of column whose value is to be deleted
+ *
+ * @param attributes Delete attributes
+ */
+ public void deleteAll(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Delete all cells that match the passed row and column and whose
+ * timestamp is equal-to or older than the passed timestamp.
+ *
+ * @param tableName name of table
+ *
+ * @param row Row to update
+ *
+ * @param column name of column whose value is to be deleted
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Delete attributes
+ */
+ public void deleteAllTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Completely delete the row's cells.
+ *
+ * @param tableName name of table
+ *
+ * @param row key of the row to be completely deleted.
+ *
+ * @param attributes Delete attributes
+ */
+ public void deleteAllRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Increment a cell by the ammount.
+ * Increments can be applied async if hbase.regionserver.thrift.coalesceIncrement is set to true.
+ * False is the default. Turn to true if you need the extra performance and can accept some
+ * data loss if a thrift server dies with increments still in the queue.
+ *
+ * @param increment The single increment to apply
+ */
+ public void increment(TIncrement increment) throws IOError, org.apache.thrift.TException;
+
+ public void incrementRows(java.util.List<TIncrement> increments) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Completely delete the row's cells marked with a timestamp
+ * equal-to or older than the passed timestamp.
+ *
+ * @param tableName name of table
+ *
+ * @param row key of the row to be completely deleted.
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Delete attributes
+ */
+ public void deleteAllRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get a scanner on the current table, using the Scan instance
+ * for the scan parameters.
+ *
+ * @param tableName name of table
+ *
+ * @param scan Scan instance
+ *
+ * @param attributes Scan attributes
+ */
+ public int scannerOpenWithScan(java.nio.ByteBuffer tableName, TScan scan, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get a scanner on the current table starting at the specified row and
+ * ending at the last row in the table. Return the specified columns.
+ *
+ * @return scanner id to be used with other scanner procedures
+ *
+ * @param tableName name of table
+ *
+ * @param startRow Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ *
+ * @param columns columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ *
+ * @param attributes Scan attributes
+ */
+ public int scannerOpen(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get a scanner on the current table starting and stopping at the
+ * specified rows. ending at the last row in the table. Return the
+ * specified columns.
+ *
+ * @return scanner id to be used with other scanner procedures
+ *
+ * @param tableName name of table
+ *
+ * @param startRow Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ *
+ * @param stopRow row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ *
+ * @param columns columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ *
+ * @param attributes Scan attributes
+ */
+ public int scannerOpenWithStop(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Open a scanner for a given prefix. That is all rows will have the specified
+ * prefix. No other rows will be returned.
+ *
+ * @return scanner id to use with other scanner calls
+ *
+ * @param tableName name of table
+ *
+ * @param startAndPrefix the prefix (and thus start row) of the keys you want
+ *
+ * @param columns the columns you want returned
+ *
+ * @param attributes Scan attributes
+ */
+ public int scannerOpenWithPrefix(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startAndPrefix, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get a scanner on the current table starting at the specified row and
+ * ending at the last row in the table. Return the specified columns.
+ * Only values with the specified timestamp are returned.
+ *
+ * @return scanner id to be used with other scanner procedures
+ *
+ * @param tableName name of table
+ *
+ * @param startRow Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ *
+ * @param columns columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Scan attributes
+ */
+ public int scannerOpenTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Get a scanner on the current table starting and stopping at the
+ * specified rows. ending at the last row in the table. Return the
+ * specified columns. Only values with the specified timestamp are
+ * returned.
+ *
+ * @return scanner id to be used with other scanner procedures
+ *
+ * @param tableName name of table
+ *
+ * @param startRow Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ *
+ * @param stopRow row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ *
+ * @param columns columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ *
+ * @param timestamp timestamp
+ *
+ * @param attributes Scan attributes
+ */
+ public int scannerOpenWithStopTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Returns the scanner's current row value and advances to the next
+ * row in the table. When there are no more rows in the table, or a key
+ * greater-than-or-equal-to the scanner's specified stopRow is reached,
+ * an empty list is returned.
+ *
+ * @return a TRowResult containing the current row and a map of the columns to TCells.
+ *
+ * @throws IllegalArgument if ScannerID is invalid
+ *
+ * @throws NotFound when the scanner reaches the end
+ *
+ * @param id id of a scanner returned by scannerOpen
+ */
+ public java.util.List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Returns, starting at the scanner's current row value nbRows worth of
+ * rows and advances to the next row in the table. When there are no more
+ * rows in the table, or a key greater-than-or-equal-to the scanner's
+ * specified stopRow is reached, an empty list is returned.
+ *
+ * @return a TRowResult containing the current row and a map of the columns to TCells.
+ *
+ * @throws IllegalArgument if ScannerID is invalid
+ *
+ * @throws NotFound when the scanner reaches the end
+ *
+ * @param id id of a scanner returned by scannerOpen
+ *
+ * @param nbRows number of results to return
+ */
+ public java.util.List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Closes the server-state associated with an open scanner.
+ *
+ * @throws IllegalArgument if ScannerID is invalid
+ *
+ * @param id id of a scanner returned by scannerOpen
+ */
+ public void scannerClose(int id) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Get the regininfo for the specified row. It scans
+ * the metatable to find region's start and end keys.
+ *
+ * @return value for specified row/column
+ *
+ * @param row row key
+ */
+ public TRegionInfo getRegionInfo(java.nio.ByteBuffer row) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Appends values to one or more columns within a single row.
+ *
+ * @return values of columns after the append operation.
+ *
+ * @param append The single append operation to apply
+ */
+ public java.util.List<TCell> append(TAppend append) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it adds the corresponding mutation operation for put.
+ *
+ * @return true if the new put was executed, false otherwise
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param column column name
+ *
+ * @param value the expected value for the column parameter, if not
+ * provided the check is for the non-existence of the
+ * column in question
+ *
+ * @param mput mutation for the put
+ *
+ * @param attributes Mutation attributes
+ */
+ public boolean checkAndPut(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.nio.ByteBuffer value, Mutation mput, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Get the type of this thrift server.
+ *
+ * @return the type of this thrift server
+ */
+ public TThriftServerType getThriftServerType() throws org.apache.thrift.TException;
+
+ /**
+ * Returns the cluster ID for this cluster.
+ */
+ public java.lang.String getClusterId() throws org.apache.thrift.TException;
+
+ /**
+ * Grant permissions in namespace or table level.
+ *
+ * @param info
+ */
+ public boolean grant(TAccessControlEntity info) throws IOError, org.apache.thrift.TException;
+
+ /**
+ * Revoke permissions in namespace or table level.
+ *
+ * @param info
+ */
+ public boolean revoke(TAccessControlEntity info) throws IOError, org.apache.thrift.TException;
+
+ }
+
+ public interface AsyncIface {
+
+ public void enableTable(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void disableTable(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void isTableEnabled(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void compact(java.nio.ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void majorCompact(java.nio.ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableNames(org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.nio.ByteBuffer>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableNamesWithIsTableEnabled(org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getColumnDescriptors(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableRegions(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRegionInfo>> resultHandler) throws org.apache.thrift.TException;
+
+ public void createTable(java.nio.ByteBuffer tableName, java.util.List<ColumnDescriptor> columnFamilies, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteTable(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void get(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getVer(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getVerTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRowWithColumns(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRowWithColumnsTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRows(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRowsWithColumns(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRowsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRowsWithColumnsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void mutateRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void mutateRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void mutateRows(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void mutateRowsTs(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void atomicIncrement(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long value, org.apache.thrift.async.AsyncMethodCallback<java.lang.Long> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteAll(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteAllTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteAllRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void increment(TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void incrementRows(java.util.List<TIncrement> increments, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteAllRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerOpenWithScan(java.nio.ByteBuffer tableName, TScan scan, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerOpen(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerOpenWithStop(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerOpenWithPrefix(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startAndPrefix, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerOpenTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerOpenWithStopTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerGet(int id, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerGetList(int id, int nbRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void scannerClose(int id, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRegionInfo(java.nio.ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback<TRegionInfo> resultHandler) throws org.apache.thrift.TException;
+
+ public void append(TAppend append, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException;
+
+ public void checkAndPut(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.nio.ByteBuffer value, Mutation mput, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void getThriftServerType(org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler) throws org.apache.thrift.TException;
+
+ public void getClusterId(org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler) throws org.apache.thrift.TException;
+
+ public void grant(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void revoke(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ }
+
+ public static class Client extends org.apache.thrift.TServiceClient implements Iface {
+ public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
+ public Factory() {}
+ public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
+ return new Client(prot);
+ }
+ public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
+ return new Client(iprot, oprot);
+ }
+ }
+
+ public Client(org.apache.thrift.protocol.TProtocol prot)
+ {
+ super(prot, prot);
+ }
+
+ public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
+ super(iprot, oprot);
+ }
+
+ public void enableTable(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException
+ {
+ send_enableTable(tableName);
+ recv_enableTable();
+ }
+
+ public void send_enableTable(java.nio.ByteBuffer tableName) throws org.apache.thrift.TException
+ {
+ enableTable_args args = new enableTable_args();
+ args.setTableName(tableName);
+ sendBase("enableTable", args);
+ }
+
+ public void recv_enableTable() throws IOError, org.apache.thrift.TException
+ {
+ enableTable_result result = new enableTable_result();
+ receiveBase(result, "enableTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void disableTable(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException
+ {
+ send_disableTable(tableName);
+ recv_disableTable();
+ }
+
+ public void send_disableTable(java.nio.ByteBuffer tableName) throws org.apache.thrift.TException
+ {
+ disableTable_args args = new disableTable_args();
+ args.setTableName(tableName);
+ sendBase("disableTable", args);
+ }
+
+ public void recv_disableTable() throws IOError, org.apache.thrift.TException
+ {
+ disableTable_result result = new disableTable_result();
+ receiveBase(result, "disableTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public boolean isTableEnabled(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException
+ {
+ send_isTableEnabled(tableName);
+ return recv_isTableEnabled();
+ }
+
+ public void send_isTableEnabled(java.nio.ByteBuffer tableName) throws org.apache.thrift.TException
+ {
+ isTableEnabled_args args = new isTableEnabled_args();
+ args.setTableName(tableName);
+ sendBase("isTableEnabled", args);
+ }
+
+ public boolean recv_isTableEnabled() throws IOError, org.apache.thrift.TException
+ {
+ isTableEnabled_result result = new isTableEnabled_result();
+ receiveBase(result, "isTableEnabled");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
+ }
+
+ public void compact(java.nio.ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException
+ {
+ send_compact(tableNameOrRegionName);
+ recv_compact();
+ }
+
+ public void send_compact(java.nio.ByteBuffer tableNameOrRegionName) throws org.apache.thrift.TException
+ {
+ compact_args args = new compact_args();
+ args.setTableNameOrRegionName(tableNameOrRegionName);
+ sendBase("compact", args);
+ }
+
+ public void recv_compact() throws IOError, org.apache.thrift.TException
+ {
+ compact_result result = new compact_result();
+ receiveBase(result, "compact");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void majorCompact(java.nio.ByteBuffer tableNameOrRegionName) throws IOError, org.apache.thrift.TException
+ {
+ send_majorCompact(tableNameOrRegionName);
+ recv_majorCompact();
+ }
+
+ public void send_majorCompact(java.nio.ByteBuffer tableNameOrRegionName) throws org.apache.thrift.TException
+ {
+ majorCompact_args args = new majorCompact_args();
+ args.setTableNameOrRegionName(tableNameOrRegionName);
+ sendBase("majorCompact", args);
+ }
+
+ public void recv_majorCompact() throws IOError, org.apache.thrift.TException
+ {
+ majorCompact_result result = new majorCompact_result();
+ receiveBase(result, "majorCompact");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public java.util.List<java.nio.ByteBuffer> getTableNames() throws IOError, org.apache.thrift.TException
+ {
+ send_getTableNames();
+ return recv_getTableNames();
+ }
+
+ public void send_getTableNames() throws org.apache.thrift.TException
+ {
+ getTableNames_args args = new getTableNames_args();
+ sendBase("getTableNames", args);
+ }
+
+ public java.util.List<java.nio.ByteBuffer> recv_getTableNames() throws IOError, org.apache.thrift.TException
+ {
+ getTableNames_result result = new getTableNames_result();
+ receiveBase(result, "getTableNames");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
+ }
+
+ public java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> getTableNamesWithIsTableEnabled() throws IOError, org.apache.thrift.TException
+ {
+ send_getTableNamesWithIsTableEnabled();
+ return recv_getTableNamesWithIsTableEnabled();
+ }
+
+ public void send_getTableNamesWithIsTableEnabled() throws org.apache.thrift.TException
+ {
+ getTableNamesWithIsTableEnabled_args args = new getTableNamesWithIsTableEnabled_args();
+ sendBase("getTableNamesWithIsTableEnabled", args);
+ }
+
+ public java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> recv_getTableNamesWithIsTableEnabled() throws IOError, org.apache.thrift.TException
+ {
+ getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result();
+ receiveBase(result, "getTableNamesWithIsTableEnabled");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableNamesWithIsTableEnabled failed: unknown result");
+ }
+
+ public java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> getColumnDescriptors(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException
+ {
+ send_getColumnDescriptors(tableName);
+ return recv_getColumnDescriptors();
+ }
+
+ public void send_getColumnDescriptors(java.nio.ByteBuffer tableName) throws org.apache.thrift.TException
+ {
+ getColumnDescriptors_args args = new getColumnDescriptors_args();
+ args.setTableName(tableName);
+ sendBase("getColumnDescriptors", args);
+ }
+
+ public java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> recv_getColumnDescriptors() throws IOError, org.apache.thrift.TException
+ {
+ getColumnDescriptors_result result = new getColumnDescriptors_result();
+ receiveBase(result, "getColumnDescriptors");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
+ }
+
+ public java.util.List<TRegionInfo> getTableRegions(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException
+ {
+ send_getTableRegions(tableName);
+ return recv_getTableRegions();
+ }
+
+ public void send_getTableRegions(java.nio.ByteBuffer tableName) throws org.apache.thrift.TException
+ {
+ getTableRegions_args args = new getTableRegions_args();
+ args.setTableName(tableName);
+ sendBase("getTableRegions", args);
+ }
+
+ public java.util.List<TRegionInfo> recv_getTableRegions() throws IOError, org.apache.thrift.TException
+ {
+ getTableRegions_result result = new getTableRegions_result();
+ receiveBase(result, "getTableRegions");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
+ }
+
+ public void createTable(java.nio.ByteBuffer tableName, java.util.List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException
+ {
+ send_createTable(tableName, columnFamilies);
+ recv_createTable();
+ }
+
+ public void send_createTable(java.nio.ByteBuffer tableName, java.util.List<ColumnDescriptor> columnFamilies) throws org.apache.thrift.TException
+ {
+ createTable_args args = new createTable_args();
+ args.setTableName(tableName);
+ args.setColumnFamilies(columnFamilies);
+ sendBase("createTable", args);
+ }
+
+ public void recv_createTable() throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException
+ {
+ createTable_result result = new createTable_result();
+ receiveBase(result, "createTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ if (result.exist != null) {
+ throw result.exist;
+ }
+ return;
+ }
+
+ public void deleteTable(java.nio.ByteBuffer tableName) throws IOError, org.apache.thrift.TException
+ {
+ send_deleteTable(tableName);
+ recv_deleteTable();
+ }
+
+ public void send_deleteTable(java.nio.ByteBuffer tableName) throws org.apache.thrift.TException
+ {
+ deleteTable_args args = new deleteTable_args();
+ args.setTableName(tableName);
+ sendBase("deleteTable", args);
+ }
+
+ public void recv_deleteTable() throws IOError, org.apache.thrift.TException
+ {
+ deleteTable_result result = new deleteTable_result();
+ receiveBase(result, "deleteTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public java.util.List<TCell> get(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_get(tableName, row, column, attributes);
+ return recv_get();
+ }
+
+ public void send_get(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ get_args args = new get_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setAttributes(attributes);
+ sendBase("get", args);
+ }
+
+ public java.util.List<TCell> recv_get() throws IOError, org.apache.thrift.TException
+ {
+ get_result result = new get_result();
+ receiveBase(result, "get");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
+ }
+
+ public java.util.List<TCell> getVer(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getVer(tableName, row, column, numVersions, attributes);
+ return recv_getVer();
+ }
+
+ public void send_getVer(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getVer_args args = new getVer_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setNumVersions(numVersions);
+ args.setAttributes(attributes);
+ sendBase("getVer", args);
+ }
+
+ public java.util.List<TCell> recv_getVer() throws IOError, org.apache.thrift.TException
+ {
+ getVer_result result = new getVer_result();
+ receiveBase(result, "getVer");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
+ }
+
+ public java.util.List<TCell> getVerTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getVerTs(tableName, row, column, timestamp, numVersions, attributes);
+ return recv_getVerTs();
+ }
+
+ public void send_getVerTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getVerTs_args args = new getVerTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setTimestamp(timestamp);
+ args.setNumVersions(numVersions);
+ args.setAttributes(attributes);
+ sendBase("getVerTs", args);
+ }
+
+ public java.util.List<TCell> recv_getVerTs() throws IOError, org.apache.thrift.TException
+ {
+ getVerTs_result result = new getVerTs_result();
+ receiveBase(result, "getVerTs");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRow(tableName, row, attributes);
+ return recv_getRow();
+ }
+
+ public void send_getRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRow_args args = new getRow_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setAttributes(attributes);
+ sendBase("getRow", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRow() throws IOError, org.apache.thrift.TException
+ {
+ getRow_result result = new getRow_result();
+ receiveBase(result, "getRow");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRowWithColumns(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRowWithColumns(tableName, row, columns, attributes);
+ return recv_getRowWithColumns();
+ }
+
+ public void send_getRowWithColumns(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRowWithColumns_args args = new getRowWithColumns_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ sendBase("getRowWithColumns", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRowWithColumns() throws IOError, org.apache.thrift.TException
+ {
+ getRowWithColumns_result result = new getRowWithColumns_result();
+ receiveBase(result, "getRowWithColumns");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRowTs(tableName, row, timestamp, attributes);
+ return recv_getRowTs();
+ }
+
+ public void send_getRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRowTs_args args = new getRowTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("getRowTs", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRowTs() throws IOError, org.apache.thrift.TException
+ {
+ getRowTs_result result = new getRowTs_result();
+ receiveBase(result, "getRowTs");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRowWithColumnsTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRowWithColumnsTs(tableName, row, columns, timestamp, attributes);
+ return recv_getRowWithColumnsTs();
+ }
+
+ public void send_getRowWithColumnsTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("getRowWithColumnsTs", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRowWithColumnsTs() throws IOError, org.apache.thrift.TException
+ {
+ getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
+ receiveBase(result, "getRowWithColumnsTs");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRows(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRows(tableName, rows, attributes);
+ return recv_getRows();
+ }
+
+ public void send_getRows(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRows_args args = new getRows_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setAttributes(attributes);
+ sendBase("getRows", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRows() throws IOError, org.apache.thrift.TException
+ {
+ getRows_result result = new getRows_result();
+ receiveBase(result, "getRows");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRows failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRowsWithColumns(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRowsWithColumns(tableName, rows, columns, attributes);
+ return recv_getRowsWithColumns();
+ }
+
+ public void send_getRowsWithColumns(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRowsWithColumns_args args = new getRowsWithColumns_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ sendBase("getRowsWithColumns", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRowsWithColumns() throws IOError, org.apache.thrift.TException
+ {
+ getRowsWithColumns_result result = new getRowsWithColumns_result();
+ receiveBase(result, "getRowsWithColumns");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRowsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRowsTs(tableName, rows, timestamp, attributes);
+ return recv_getRowsTs();
+ }
+
+ public void send_getRowsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRowsTs_args args = new getRowsTs_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("getRowsTs", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRowsTs() throws IOError, org.apache.thrift.TException
+ {
+ getRowsTs_result result = new getRowsTs_result();
+ receiveBase(result, "getRowsTs");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> getRowsWithColumnsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_getRowsWithColumnsTs(tableName, rows, columns, timestamp, attributes);
+ return recv_getRowsWithColumnsTs();
+ }
+
+ public void send_getRowsWithColumnsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("getRowsWithColumnsTs", args);
+ }
+
+ public java.util.List<TRowResult> recv_getRowsWithColumnsTs() throws IOError, org.apache.thrift.TException
+ {
+ getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
+ receiveBase(result, "getRowsWithColumnsTs");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
+ }
+
+ public void mutateRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_mutateRow(tableName, row, mutations, attributes);
+ recv_mutateRow();
+ }
+
+ public void send_mutateRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ mutateRow_args args = new mutateRow_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setMutations(mutations);
+ args.setAttributes(attributes);
+ sendBase("mutateRow", args);
+ }
+
+ public void recv_mutateRow() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ mutateRow_result result = new mutateRow_result();
+ receiveBase(result, "mutateRow");
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ return;
+ }
+
+ public void mutateRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_mutateRowTs(tableName, row, mutations, timestamp, attributes);
+ recv_mutateRowTs();
+ }
+
+ public void send_mutateRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ mutateRowTs_args args = new mutateRowTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setMutations(mutations);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("mutateRowTs", args);
+ }
+
+ public void recv_mutateRowTs() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ mutateRowTs_result result = new mutateRowTs_result();
+ receiveBase(result, "mutateRowTs");
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ return;
+ }
+
+ public void mutateRows(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_mutateRows(tableName, rowBatches, attributes);
+ recv_mutateRows();
+ }
+
+ public void send_mutateRows(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ mutateRows_args args = new mutateRows_args();
+ args.setTableName(tableName);
+ args.setRowBatches(rowBatches);
+ args.setAttributes(attributes);
+ sendBase("mutateRows", args);
+ }
+
+ public void recv_mutateRows() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ mutateRows_result result = new mutateRows_result();
+ receiveBase(result, "mutateRows");
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ return;
+ }
+
+ public void mutateRowsTs(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_mutateRowsTs(tableName, rowBatches, timestamp, attributes);
+ recv_mutateRowsTs();
+ }
+
+ public void send_mutateRowsTs(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ mutateRowsTs_args args = new mutateRowsTs_args();
+ args.setTableName(tableName);
+ args.setRowBatches(rowBatches);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("mutateRowsTs", args);
+ }
+
+ public void recv_mutateRowsTs() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ mutateRowsTs_result result = new mutateRowsTs_result();
+ receiveBase(result, "mutateRowsTs");
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ return;
+ }
+
+ public long atomicIncrement(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long value) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_atomicIncrement(tableName, row, column, value);
+ return recv_atomicIncrement();
+ }
+
+ public void send_atomicIncrement(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long value) throws org.apache.thrift.TException
+ {
+ atomicIncrement_args args = new atomicIncrement_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setValue(value);
+ sendBase("atomicIncrement", args);
+ }
+
+ public long recv_atomicIncrement() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ atomicIncrement_result result = new atomicIncrement_result();
+ receiveBase(result, "atomicIncrement");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result");
+ }
+
+ public void deleteAll(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_deleteAll(tableName, row, column, attributes);
+ recv_deleteAll();
+ }
+
+ public void send_deleteAll(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ deleteAll_args args = new deleteAll_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setAttributes(attributes);
+ sendBase("deleteAll", args);
+ }
+
+ public void recv_deleteAll() throws IOError, org.apache.thrift.TException
+ {
+ deleteAll_result result = new deleteAll_result();
+ receiveBase(result, "deleteAll");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void deleteAllTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_deleteAllTs(tableName, row, column, timestamp, attributes);
+ recv_deleteAllTs();
+ }
+
+ public void send_deleteAllTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ deleteAllTs_args args = new deleteAllTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("deleteAllTs", args);
+ }
+
+ public void recv_deleteAllTs() throws IOError, org.apache.thrift.TException
+ {
+ deleteAllTs_result result = new deleteAllTs_result();
+ receiveBase(result, "deleteAllTs");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void deleteAllRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_deleteAllRow(tableName, row, attributes);
+ recv_deleteAllRow();
+ }
+
+ public void send_deleteAllRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ deleteAllRow_args args = new deleteAllRow_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setAttributes(attributes);
+ sendBase("deleteAllRow", args);
+ }
+
+ public void recv_deleteAllRow() throws IOError, org.apache.thrift.TException
+ {
+ deleteAllRow_result result = new deleteAllRow_result();
+ receiveBase(result, "deleteAllRow");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void increment(TIncrement increment) throws IOError, org.apache.thrift.TException
+ {
+ send_increment(increment);
+ recv_increment();
+ }
+
+ public void send_increment(TIncrement increment) throws org.apache.thrift.TException
+ {
+ increment_args args = new increment_args();
+ args.setIncrement(increment);
+ sendBase("increment", args);
+ }
+
+ public void recv_increment() throws IOError, org.apache.thrift.TException
+ {
+ increment_result result = new increment_result();
+ receiveBase(result, "increment");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void incrementRows(java.util.List<TIncrement> increments) throws IOError, org.apache.thrift.TException
+ {
+ send_incrementRows(increments);
+ recv_incrementRows();
+ }
+
+ public void send_incrementRows(java.util.List<TIncrement> increments) throws org.apache.thrift.TException
+ {
+ incrementRows_args args = new incrementRows_args();
+ args.setIncrements(increments);
+ sendBase("incrementRows", args);
+ }
+
+ public void recv_incrementRows() throws IOError, org.apache.thrift.TException
+ {
+ incrementRows_result result = new incrementRows_result();
+ receiveBase(result, "incrementRows");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void deleteAllRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_deleteAllRowTs(tableName, row, timestamp, attributes);
+ recv_deleteAllRowTs();
+ }
+
+ public void send_deleteAllRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ deleteAllRowTs_args args = new deleteAllRowTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("deleteAllRowTs", args);
+ }
+
+ public void recv_deleteAllRowTs() throws IOError, org.apache.thrift.TException
+ {
+ deleteAllRowTs_result result = new deleteAllRowTs_result();
+ receiveBase(result, "deleteAllRowTs");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public int scannerOpenWithScan(java.nio.ByteBuffer tableName, TScan scan, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_scannerOpenWithScan(tableName, scan, attributes);
+ return recv_scannerOpenWithScan();
+ }
+
+ public void send_scannerOpenWithScan(java.nio.ByteBuffer tableName, TScan scan, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ scannerOpenWithScan_args args = new scannerOpenWithScan_args();
+ args.setTableName(tableName);
+ args.setScan(scan);
+ args.setAttributes(attributes);
+ sendBase("scannerOpenWithScan", args);
+ }
+
+ public int recv_scannerOpenWithScan() throws IOError, org.apache.thrift.TException
+ {
+ scannerOpenWithScan_result result = new scannerOpenWithScan_result();
+ receiveBase(result, "scannerOpenWithScan");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithScan failed: unknown result");
+ }
+
+ public int scannerOpen(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_scannerOpen(tableName, startRow, columns, attributes);
+ return recv_scannerOpen();
+ }
+
+ public void send_scannerOpen(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ scannerOpen_args args = new scannerOpen_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ sendBase("scannerOpen", args);
+ }
+
+ public int recv_scannerOpen() throws IOError, org.apache.thrift.TException
+ {
+ scannerOpen_result result = new scannerOpen_result();
+ receiveBase(result, "scannerOpen");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
+ }
+
+ public int scannerOpenWithStop(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes);
+ return recv_scannerOpenWithStop();
+ }
+
+ public void send_scannerOpenWithStop(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ scannerOpenWithStop_args args = new scannerOpenWithStop_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setStopRow(stopRow);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ sendBase("scannerOpenWithStop", args);
+ }
+
+ public int recv_scannerOpenWithStop() throws IOError, org.apache.thrift.TException
+ {
+ scannerOpenWithStop_result result = new scannerOpenWithStop_result();
+ receiveBase(result, "scannerOpenWithStop");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
+ }
+
+ public int scannerOpenWithPrefix(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startAndPrefix, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes);
+ return recv_scannerOpenWithPrefix();
+ }
+
+ public void send_scannerOpenWithPrefix(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startAndPrefix, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
+ args.setTableName(tableName);
+ args.setStartAndPrefix(startAndPrefix);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ sendBase("scannerOpenWithPrefix", args);
+ }
+
+ public int recv_scannerOpenWithPrefix() throws IOError, org.apache.thrift.TException
+ {
+ scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
+ receiveBase(result, "scannerOpenWithPrefix");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
+ }
+
+ public int scannerOpenTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_scannerOpenTs(tableName, startRow, columns, timestamp, attributes);
+ return recv_scannerOpenTs();
+ }
+
+ public void send_scannerOpenTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ scannerOpenTs_args args = new scannerOpenTs_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("scannerOpenTs", args);
+ }
+
+ public int recv_scannerOpenTs() throws IOError, org.apache.thrift.TException
+ {
+ scannerOpenTs_result result = new scannerOpenTs_result();
+ receiveBase(result, "scannerOpenTs");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
+ }
+
+ public int scannerOpenWithStopTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, org.apache.thrift.TException
+ {
+ send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes);
+ return recv_scannerOpenWithStopTs();
+ }
+
+ public void send_scannerOpenWithStopTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setStopRow(stopRow);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ sendBase("scannerOpenWithStopTs", args);
+ }
+
+ public int recv_scannerOpenWithStopTs() throws IOError, org.apache.thrift.TException
+ {
+ scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
+ receiveBase(result, "scannerOpenWithStopTs");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_scannerGet(id);
+ return recv_scannerGet();
+ }
+
+ public void send_scannerGet(int id) throws org.apache.thrift.TException
+ {
+ scannerGet_args args = new scannerGet_args();
+ args.setId(id);
+ sendBase("scannerGet", args);
+ }
+
+ public java.util.List<TRowResult> recv_scannerGet() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ scannerGet_result result = new scannerGet_result();
+ receiveBase(result, "scannerGet");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result");
+ }
+
+ public java.util.List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_scannerGetList(id, nbRows);
+ return recv_scannerGetList();
+ }
+
+ public void send_scannerGetList(int id, int nbRows) throws org.apache.thrift.TException
+ {
+ scannerGetList_args args = new scannerGetList_args();
+ args.setId(id);
+ args.setNbRows(nbRows);
+ sendBase("scannerGetList", args);
+ }
+
+ public java.util.List<TRowResult> recv_scannerGetList() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ scannerGetList_result result = new scannerGetList_result();
+ receiveBase(result, "scannerGetList");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result");
+ }
+
+ public void scannerClose(int id) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_scannerClose(id);
+ recv_scannerClose();
+ }
+
+ public void send_scannerClose(int id) throws org.apache.thrift.TException
+ {
+ scannerClose_args args = new scannerClose_args();
+ args.setId(id);
+ sendBase("scannerClose", args);
+ }
+
+ public void recv_scannerClose() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ scannerClose_result result = new scannerClose_result();
+ receiveBase(result, "scannerClose");
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ return;
+ }
+
+ public TRegionInfo getRegionInfo(java.nio.ByteBuffer row) throws IOError, org.apache.thrift.TException
+ {
+ send_getRegionInfo(row);
+ return recv_getRegionInfo();
+ }
+
+ public void send_getRegionInfo(java.nio.ByteBuffer row) throws org.apache.thrift.TException
+ {
+ getRegionInfo_args args = new getRegionInfo_args();
+ args.setRow(row);
+ sendBase("getRegionInfo", args);
+ }
+
+ public TRegionInfo recv_getRegionInfo() throws IOError, org.apache.thrift.TException
+ {
+ getRegionInfo_result result = new getRegionInfo_result();
+ receiveBase(result, "getRegionInfo");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRegionInfo failed: unknown result");
+ }
+
+ public java.util.List<TCell> append(TAppend append) throws IOError, org.apache.thrift.TException
+ {
+ send_append(append);
+ return recv_append();
+ }
+
+ public void send_append(TAppend append) throws org.apache.thrift.TException
+ {
+ append_args args = new append_args();
+ args.setAppend(append);
+ sendBase("append", args);
+ }
+
+ public java.util.List<TCell> recv_append() throws IOError, org.apache.thrift.TException
+ {
+ append_result result = new append_result();
+ receiveBase(result, "append");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "append failed: unknown result");
+ }
+
+ public boolean checkAndPut(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.nio.ByteBuffer value, Mutation mput, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ send_checkAndPut(tableName, row, column, value, mput, attributes);
+ return recv_checkAndPut();
+ }
+
+ public void send_checkAndPut(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.nio.ByteBuffer value, Mutation mput, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) throws org.apache.thrift.TException
+ {
+ checkAndPut_args args = new checkAndPut_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setValue(value);
+ args.setMput(mput);
+ args.setAttributes(attributes);
+ sendBase("checkAndPut", args);
+ }
+
+ public boolean recv_checkAndPut() throws IOError, IllegalArgument, org.apache.thrift.TException
+ {
+ checkAndPut_result result = new checkAndPut_result();
+ receiveBase(result, "checkAndPut");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
+ }
+
+ public TThriftServerType getThriftServerType() throws org.apache.thrift.TException
+ {
+ send_getThriftServerType();
+ return recv_getThriftServerType();
+ }
+
+ public void send_getThriftServerType() throws org.apache.thrift.TException
+ {
+ getThriftServerType_args args = new getThriftServerType_args();
+ sendBase("getThriftServerType", args);
+ }
+
+ public TThriftServerType recv_getThriftServerType() throws org.apache.thrift.TException
+ {
+ getThriftServerType_result result = new getThriftServerType_result();
+ receiveBase(result, "getThriftServerType");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getThriftServerType failed: unknown result");
+ }
+
+ public java.lang.String getClusterId() throws org.apache.thrift.TException
+ {
+ send_getClusterId();
+ return recv_getClusterId();
+ }
+
+ public void send_getClusterId() throws org.apache.thrift.TException
+ {
+ getClusterId_args args = new getClusterId_args();
+ sendBase("getClusterId", args);
+ }
+
+ public java.lang.String recv_getClusterId() throws org.apache.thrift.TException
+ {
+ getClusterId_result result = new getClusterId_result();
+ receiveBase(result, "getClusterId");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getClusterId failed: unknown result");
+ }
+
+ public boolean grant(TAccessControlEntity info) throws IOError, org.apache.thrift.TException
+ {
+ send_grant(info);
+ return recv_grant();
+ }
+
+ public void send_grant(TAccessControlEntity info) throws org.apache.thrift.TException
+ {
+ grant_args args = new grant_args();
+ args.setInfo(info);
+ sendBase("grant", args);
+ }
+
+ public boolean recv_grant() throws IOError, org.apache.thrift.TException
+ {
+ grant_result result = new grant_result();
+ receiveBase(result, "grant");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "grant failed: unknown result");
+ }
+
+ public boolean revoke(TAccessControlEntity info) throws IOError, org.apache.thrift.TException
+ {
+ send_revoke(info);
+ return recv_revoke();
+ }
+
+ public void send_revoke(TAccessControlEntity info) throws org.apache.thrift.TException
+ {
+ revoke_args args = new revoke_args();
+ args.setInfo(info);
+ sendBase("revoke", args);
+ }
+
+ public boolean recv_revoke() throws IOError, org.apache.thrift.TException
+ {
+ revoke_result result = new revoke_result();
+ receiveBase(result, "revoke");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "revoke failed: unknown result");
+ }
+
+ }
+ public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
+ public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
+ 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) {
+ this.clientManager = clientManager;
+ this.protocolFactory = protocolFactory;
+ }
+ public AsyncClient getAsyncClient(org.apache.thrift.transport.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) {
+ super(protocolFactory, clientManager, transport);
+ }
+
+ public void enableTable(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private java.nio.ByteBuffer tableName;
+ public enableTable_call(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void disableTable(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private java.nio.ByteBuffer tableName;
+ public disableTable_call(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void isTableEnabled(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.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<java.lang.Boolean> {
+ private java.nio.ByteBuffer tableName;
+ public isTableEnabled_call(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ isTableEnabled_args args = new isTableEnabled_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_isTableEnabled();
+ }
+ }
+
+ public void compact(java.nio.ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private java.nio.ByteBuffer tableNameOrRegionName;
+ public compact_call(java.nio.ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void majorCompact(java.nio.ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private java.nio.ByteBuffer tableNameOrRegionName;
+ public majorCompact_call(java.nio.ByteBuffer tableNameOrRegionName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void getTableNames(org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.nio.ByteBuffer>> resultHandler) throws org.apache.thrift.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<java.util.List<java.nio.ByteBuffer>> {
+ public getTableNames_call(org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.nio.ByteBuffer>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNames", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableNames_args args = new getTableNames_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<java.nio.ByteBuffer> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableNames();
+ }
+ }
+
+ public void getTableNamesWithIsTableEnabled(org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getTableNamesWithIsTableEnabled_call method_call = new getTableNamesWithIsTableEnabled_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getTableNamesWithIsTableEnabled_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>> {
+ public getTableNamesWithIsTableEnabled_call(org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNamesWithIsTableEnabled", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableNamesWithIsTableEnabled_args args = new getTableNamesWithIsTableEnabled_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableNamesWithIsTableEnabled();
+ }
+ }
+
+ public void getColumnDescriptors(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>> resultHandler) throws org.apache.thrift.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<java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>> {
+ private java.nio.ByteBuffer tableName;
+ public getColumnDescriptors_call(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ getColumnDescriptors_args args = new getColumnDescriptors_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getColumnDescriptors();
+ }
+ }
+
+ public void getTableRegions(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRegionInfo>> resultHandler) throws org.apache.thrift.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<java.util.List<TRegionInfo>> {
+ private java.nio.ByteBuffer tableName;
+ public getTableRegions_call(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRegionInfo>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ getTableRegions_args args = new getTableRegions_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRegionInfo> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableRegions();
+ }
+ }
+
+ public void createTable(java.nio.ByteBuffer tableName, java.util.List<ColumnDescriptor> columnFamilies, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.util.List<ColumnDescriptor> columnFamilies;
+ public createTable_call(java.nio.ByteBuffer tableName, java.util.List<ColumnDescriptor> columnFamilies, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ createTable_args args = new createTable_args();
+ args.setTableName(tableName);
+ args.setColumnFamilies(columnFamilies);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws IOError, IllegalArgument, AlreadyExists, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteTable(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private java.nio.ByteBuffer tableName;
+ public deleteTable_call(java.nio.ByteBuffer tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void get(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ get_call method_call = new get_call(tableName, row, column, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class get_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TCell>> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer column;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public get_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.column = column;
+ this.attributes = attributes;
+ }
+
+ 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));
+ get_args args = new get_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TCell> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_get();
+ }
+ }
+
+ public void getVer(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getVer_call method_call = new getVer_call(tableName, row, column, numVersions, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getVer_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TCell>> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer column;
+ private int numVersions;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getVer_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.column = column;
+ this.numVersions = numVersions;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getVer_args args = new getVer_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setNumVersions(numVersions);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TCell> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getVer();
+ }
+ }
+
+ public void getVerTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getVerTs_call method_call = new getVerTs_call(tableName, row, column, timestamp, numVersions, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getVerTs_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TCell>> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer column;
+ private long timestamp;
+ private int numVersions;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getVerTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, int numVersions, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.column = column;
+ this.timestamp = timestamp;
+ this.numVersions = numVersions;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getVerTs_args args = new getVerTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setTimestamp(timestamp);
+ args.setNumVersions(numVersions);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TCell> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getVerTs();
+ }
+ }
+
+ public void getRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRow_call method_call = new getRow_call(tableName, row, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRow_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRow_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRow_args args = new getRow_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRow();
+ }
+ }
+
+ public void getRowWithColumns(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRowWithColumns_call method_call = new getRowWithColumns_call(tableName, row, columns, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRowWithColumns_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRowWithColumns_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRowWithColumns_args args = new getRowWithColumns_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRowWithColumns();
+ }
+ }
+
+ public void getRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRowTs_call method_call = new getRowTs_call(tableName, row, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRowTs_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRowTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRowTs_args args = new getRowTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRowTs();
+ }
+ }
+
+ public void getRowWithColumnsTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRowWithColumnsTs_call method_call = new getRowWithColumnsTs_call(tableName, row, columns, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRowWithColumnsTs_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRowWithColumnsTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.columns = columns;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRowWithColumnsTs();
+ }
+ }
+
+ public void getRows(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRows_call method_call = new getRows_call(tableName, rows, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRows_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.util.List<java.nio.ByteBuffer> rows;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRows_call(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.rows = rows;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRows_args args = new getRows_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRows();
+ }
+ }
+
+ public void getRowsWithColumns(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRowsWithColumns_call method_call = new getRowsWithColumns_call(tableName, rows, columns, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRowsWithColumns_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.util.List<java.nio.ByteBuffer> rows;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRowsWithColumns_call(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.rows = rows;
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRowsWithColumns_args args = new getRowsWithColumns_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRowsWithColumns();
+ }
+ }
+
+ public void getRowsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRowsTs_call method_call = new getRowsTs_call(tableName, rows, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRowsTs_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.util.List<java.nio.ByteBuffer> rows;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRowsTs_call(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.rows = rows;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRowsTs_args args = new getRowsTs_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRowsTs();
+ }
+ }
+
+ public void getRowsWithColumnsTs(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRowsWithColumnsTs_call method_call = new getRowsWithColumnsTs_call(tableName, rows, columns, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRowsWithColumnsTs_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TRowResult>> {
+ private java.nio.ByteBuffer tableName;
+ private java.util.List<java.nio.ByteBuffer> rows;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public getRowsWithColumnsTs_call(java.nio.ByteBuffer tableName, java.util.List<java.nio.ByteBuffer> rows, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.rows = rows;
+ this.columns = columns;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
+ args.setTableName(tableName);
+ args.setRows(rows);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRowsWithColumnsTs();
+ }
+ }
+
+ public void mutateRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ mutateRow_call method_call = new mutateRow_call(tableName, row, mutations, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class mutateRow_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.util.List<Mutation> mutations;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public mutateRow_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.mutations = mutations;
+ this.attributes = attributes;
+ }
+
+ 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));
+ mutateRow_args args = new mutateRow_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setMutations(mutations);
+ args.setAttributes(attributes);
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void mutateRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ mutateRowTs_call method_call = new mutateRowTs_call(tableName, row, mutations, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class mutateRowTs_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.util.List<Mutation> mutations;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public mutateRowTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.List<Mutation> mutations, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.mutations = mutations;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ mutateRowTs_args args = new mutateRowTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setMutations(mutations);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void mutateRows(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ mutateRows_call method_call = new mutateRows_call(tableName, rowBatches, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class mutateRows_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.util.List<BatchMutation> rowBatches;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public mutateRows_call(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.rowBatches = rowBatches;
+ this.attributes = attributes;
+ }
+
+ 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));
+ mutateRows_args args = new mutateRows_args();
+ args.setTableName(tableName);
+ args.setRowBatches(rowBatches);
+ args.setAttributes(attributes);
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void mutateRowsTs(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ mutateRowsTs_call method_call = new mutateRowsTs_call(tableName, rowBatches, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class mutateRowsTs_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.util.List<BatchMutation> rowBatches;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public mutateRowsTs_call(java.nio.ByteBuffer tableName, java.util.List<BatchMutation> rowBatches, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.rowBatches = rowBatches;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ mutateRowsTs_args args = new mutateRowsTs_args();
+ args.setTableName(tableName);
+ args.setRowBatches(rowBatches);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void atomicIncrement(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long value, org.apache.thrift.async.AsyncMethodCallback<java.lang.Long> resultHandler) throws org.apache.thrift.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<java.lang.Long> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer column;
+ private long value;
+ public atomicIncrement_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long value, org.apache.thrift.async.AsyncMethodCallback<java.lang.Long> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.column = column;
+ 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));
+ atomicIncrement_args args = new atomicIncrement_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setValue(value);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Long getResult() throws IOError, IllegalArgument, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_atomicIncrement();
+ }
+ }
+
+ public void deleteAll(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteAll_call method_call = new deleteAll_call(tableName, row, column, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteAll_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer column;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public deleteAll_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.column = column;
+ this.attributes = attributes;
+ }
+
+ 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));
+ deleteAll_args args = new deleteAll_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteAllTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteAllTs_call method_call = new deleteAllTs_call(tableName, row, column, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteAllTs_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer column;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public deleteAllTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.column = column;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ deleteAllTs_args args = new deleteAllTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteAllRow(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteAllRow_call method_call = new deleteAllRow_call(tableName, row, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteAllRow_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public deleteAllRow_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.attributes = attributes;
+ }
+
+ 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));
+ deleteAllRow_args args = new deleteAllRow_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void increment(TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ increment_call method_call = new increment_call(increment, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TIncrement increment;
+ public increment_call(TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.increment = increment;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ increment_args args = new increment_args();
+ args.setIncrement(increment);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void incrementRows(java.util.List<TIncrement> increments, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ incrementRows_call method_call = new incrementRows_call(increments, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class incrementRows_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.util.List<TIncrement> increments;
+ public incrementRows_call(java.util.List<TIncrement> increments, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.increments = increments;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("incrementRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ incrementRows_args args = new incrementRows_args();
+ args.setIncrements(increments);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteAllRowTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteAllRowTs_call method_call = new deleteAllRowTs_call(tableName, row, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteAllRowTs_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public deleteAllRowTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ deleteAllRowTs_args args = new deleteAllRowTs_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void scannerOpenWithScan(java.nio.ByteBuffer tableName, TScan scan, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ scannerOpenWithScan_call method_call = new scannerOpenWithScan_call(tableName, scan, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class scannerOpenWithScan_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Integer> {
+ private java.nio.ByteBuffer tableName;
+ private TScan scan;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public scannerOpenWithScan_call(java.nio.ByteBuffer tableName, TScan scan, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.scan = scan;
+ this.attributes = attributes;
+ }
+
+ 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));
+ scannerOpenWithScan_args args = new scannerOpenWithScan_args();
+ args.setTableName(tableName);
+ args.setScan(scan);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Integer getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerOpenWithScan();
+ }
+ }
+
+ public void scannerOpen(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ scannerOpen_call method_call = new scannerOpen_call(tableName, startRow, columns, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class scannerOpen_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Integer> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer startRow;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public scannerOpen_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.startRow = startRow;
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ 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));
+ scannerOpen_args args = new scannerOpen_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Integer getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerOpen();
+ }
+ }
+
+ public void scannerOpenWithStop(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ scannerOpenWithStop_call method_call = new scannerOpenWithStop_call(tableName, startRow, stopRow, columns, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class scannerOpenWithStop_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Integer> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer startRow;
+ private java.nio.ByteBuffer stopRow;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public scannerOpenWithStop_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.startRow = startRow;
+ this.stopRow = stopRow;
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ 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));
+ scannerOpenWithStop_args args = new scannerOpenWithStop_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setStopRow(stopRow);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Integer getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerOpenWithStop();
+ }
+ }
+
+ public void scannerOpenWithPrefix(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startAndPrefix, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ scannerOpenWithPrefix_call method_call = new scannerOpenWithPrefix_call(tableName, startAndPrefix, columns, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class scannerOpenWithPrefix_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Integer> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer startAndPrefix;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public scannerOpenWithPrefix_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startAndPrefix, java.util.List<java.nio.ByteBuffer> columns, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.startAndPrefix = startAndPrefix;
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ 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));
+ scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
+ args.setTableName(tableName);
+ args.setStartAndPrefix(startAndPrefix);
+ args.setColumns(columns);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Integer getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerOpenWithPrefix();
+ }
+ }
+
+ public void scannerOpenTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ scannerOpenTs_call method_call = new scannerOpenTs_call(tableName, startRow, columns, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class scannerOpenTs_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Integer> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer startRow;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public scannerOpenTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.startRow = startRow;
+ this.columns = columns;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ scannerOpenTs_args args = new scannerOpenTs_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Integer getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerOpenTs();
+ }
+ }
+
+ public void scannerOpenWithStopTs(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ scannerOpenWithStopTs_call method_call = new scannerOpenWithStopTs_call(tableName, startRow, stopRow, columns, timestamp, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class scannerOpenWithStopTs_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Integer> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer startRow;
+ private java.nio.ByteBuffer stopRow;
+ private java.util.List<java.nio.ByteBuffer> columns;
+ private long timestamp;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public scannerOpenWithStopTs_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer startRow, java.nio.ByteBuffer stopRow, java.util.List<java.nio.ByteBuffer> columns, long timestamp, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.startRow = startRow;
+ this.stopRow = stopRow;
+ this.columns = columns;
+ this.timestamp = timestamp;
+ this.attributes = attributes;
+ }
+
+ 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));
+ scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
+ args.setTableName(tableName);
+ args.setStartRow(startRow);
+ args.setStopRow(stopRow);
+ args.setColumns(columns);
+ args.setTimestamp(timestamp);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Integer getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerOpenWithStopTs();
+ }
+ }
+
+ public void scannerGet(int id, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.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<java.util.List<TRowResult>> {
+ private int id;
+ public scannerGet_call(int id, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ scannerGet_args args = new scannerGet_args();
+ args.setId(id);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, IllegalArgument, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerGet();
+ }
+ }
+
+ public void scannerGetList(int id, int nbRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.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<java.util.List<TRowResult>> {
+ private int id;
+ private int nbRows;
+ public scannerGetList_call(int id, int nbRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ scannerGetList_args args = new scannerGetList_args();
+ args.setId(id);
+ args.setNbRows(nbRows);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TRowResult> getResult() throws IOError, IllegalArgument, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_scannerGetList();
+ }
+ }
+
+ public void scannerClose(int id, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private int id;
+ public scannerClose_call(int id, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ 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) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void getRegionInfo(java.nio.ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback<TRegionInfo> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRegionInfo_call method_call = new getRegionInfo_call(row, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRegionInfo_call extends org.apache.thrift.async.TAsyncMethodCall<TRegionInfo> {
+ private java.nio.ByteBuffer row;
+ public getRegionInfo_call(java.nio.ByteBuffer row, org.apache.thrift.async.AsyncMethodCallback<TRegionInfo> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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("getRegionInfo", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getRegionInfo_args args = new getRegionInfo_args();
+ args.setRow(row);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TRegionInfo getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRegionInfo();
+ }
+ }
+
+ public void append(TAppend append, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ append_call method_call = new append_call(append, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class append_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TCell>> {
+ private TAppend append;
+ public append_call(TAppend append, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.append = append;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("append", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ append_args args = new append_args();
+ args.setAppend(append);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TCell> getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_append();
+ }
+ }
+
+ public void checkAndPut(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.nio.ByteBuffer value, Mutation mput, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ checkAndPut_call method_call = new checkAndPut_call(tableName, row, column, value, mput, attributes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private java.nio.ByteBuffer tableName;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer column;
+ private java.nio.ByteBuffer value;
+ private Mutation mput;
+ private java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes;
+ public checkAndPut_call(java.nio.ByteBuffer tableName, java.nio.ByteBuffer row, java.nio.ByteBuffer column, java.nio.ByteBuffer value, Mutation mput, java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.row = row;
+ this.column = column;
+ this.value = value;
+ this.mput = mput;
+ this.attributes = attributes;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ checkAndPut_args args = new checkAndPut_args();
+ args.setTableName(tableName);
+ args.setRow(row);
+ args.setColumn(column);
+ args.setValue(value);
+ args.setMput(mput);
+ args.setAttributes(attributes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws IOError, IllegalArgument, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_checkAndPut();
+ }
+ }
+
+ public void getThriftServerType(org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getThriftServerType_call method_call = new getThriftServerType_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getThriftServerType_call extends org.apache.thrift.async.TAsyncMethodCall<TThriftServerType> {
+ public getThriftServerType_call(org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getThriftServerType", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getThriftServerType_args args = new getThriftServerType_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TThriftServerType getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getThriftServerType();
+ }
+ }
+
+ public void getClusterId(org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getClusterId_call method_call = new getClusterId_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getClusterId_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.String> {
+ public getClusterId_call(org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getClusterId", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getClusterId_args args = new getClusterId_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.String getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getClusterId();
+ }
+ }
+
+ public void grant(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ grant_call method_call = new grant_call(info, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class grant_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TAccessControlEntity info;
+ public grant_call(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.info = info;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("grant", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ grant_args args = new grant_args();
+ args.setInfo(info);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_grant();
+ }
+ }
+
+ public void revoke(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ revoke_call method_call = new revoke_call(info, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class revoke_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TAccessControlEntity info;
+ public revoke_call(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.info = info;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("revoke", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ revoke_args args = new revoke_args();
+ args.setInfo(info);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws IOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_revoke();
+ }
+ }
+
+ }
+
+ public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
+ private static final org.slf4j.Logger _LOGGER = org.slf4j.LoggerFactory.getLogger(Processor.class.getName());
+ public Processor(I iface) {
+ super(iface, getProcessMap(new java.util.HashMap<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
+ }
+
+ protected Processor(I iface, java.util.Map<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
+ super(iface, getProcessMap(processMap));
+ }
+
+ private static <I extends Iface> java.util.Map<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> getProcessMap(java.util.Map<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
+ processMap.put("enableTable", new enableTable());
+ processMap.put("disableTable", new disableTable());
+ processMap.put("isTableEnabled", new isTableEnabled());
+ processMap.put("compact", new compact());
+ processMap.put("majorCompact", new majorCompact());
+ processMap.put("getTableNames", new getTableNames());
+ processMap.put("getTableNamesWithIsTableEnabled", new getTableNamesWithIsTableEnabled());
+ processMap.put("getColumnDescriptors", new getColumnDescriptors());
+ processMap.put("getTableRegions", new getTableRegions());
+ processMap.put("createTable", new createTable());
+ processMap.put("deleteTable", new deleteTable());
+ processMap.put("get", new get());
+ processMap.put("getVer", new getVer());
+ processMap.put("getVerTs", new getVerTs());
+ processMap.put("getRow", new getRow());
+ processMap.put("getRowWithColumns", new getRowWithColumns());
+ processMap.put("getRowTs", new getRowTs());
+ processMap.put("getRowWithColumnsTs", new getRowWithColumnsTs());
+ processMap.put("getRows", new getRows());
+ processMap.put("getRowsWithColumns", new getRowsWithColumns());
+ processMap.put("getRowsTs", new getRowsTs());
+ processMap.put("getRowsWithColumnsTs", new getRowsWithColumnsTs());
+ processMap.put("mutateRow", new mutateRow());
+ processMap.put("mutateRowTs", new mutateRowTs());
+ processMap.put("mutateRows", new mutateRows());
+ processMap.put("mutateRowsTs", new mutateRowsTs());
+ processMap.put("atomicIncrement", new atomicIncrement());
+ processMap.put("deleteAll", new deleteAll());
+ processMap.put("deleteAllTs", new deleteAllTs());
+ processMap.put("deleteAllRow", new deleteAllRow());
+ processMap.put("increment", new increment());
+ processMap.put("incrementRows", new incrementRows());
+ processMap.put("deleteAllRowTs", new deleteAllRowTs());
+ processMap.put("scannerOpenWithScan", new scannerOpenWithScan());
+ processMap.put("scannerOpen", new scannerOpen());
+ processMap.put("scannerOpenWithStop", new scannerOpenWithStop());
+ processMap.put("scannerOpenWithPrefix", new scannerOpenWithPrefix());
+ processMap.put("scannerOpenTs", new scannerOpenTs());
+ processMap.put("scannerOpenWithStopTs", new scannerOpenWithStopTs());
+ processMap.put("scannerGet", new scannerGet());
+ processMap.put("scannerGetList", new scannerGetList());
+ processMap.put("scannerClose", new scannerClose());
+ processMap.put("getRegionInfo", new getRegionInfo());
+ processMap.put("append", new append());
+ processMap.put("checkAndPut", new checkAndPut());
+ processMap.put("getThriftServerType", new getThriftServerType());
+ processMap.put("getClusterId", new getClusterId());
+ processMap.put("grant", new grant());
+ processMap.put("revoke", new revoke());
+ return processMap;
+ }
+
+ public static class enableTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, enableTable_args> {
+ public enableTable() {
+ super("enableTable");
+ }
+
+ public enableTable_args getEmptyArgsInstance() {
+ return new enableTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public enableTable_result getResult(I iface, enableTable_args args) throws org.apache.thrift.TException {
+ enableTable_result result = new enableTable_result();
+ try {
+ iface.enableTable(args.tableName);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class disableTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, disableTable_args> {
+ public disableTable() {
+ super("disableTable");
+ }
+
+ public disableTable_args getEmptyArgsInstance() {
+ return new disableTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public disableTable_result getResult(I iface, disableTable_args args) throws org.apache.thrift.TException {
+ disableTable_result result = new disableTable_result();
+ try {
+ iface.disableTable(args.tableName);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class isTableEnabled<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTableEnabled_args> {
+ public isTableEnabled() {
+ super("isTableEnabled");
+ }
+
+ public isTableEnabled_args getEmptyArgsInstance() {
+ return new isTableEnabled_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public isTableEnabled_result getResult(I iface, isTableEnabled_args args) throws org.apache.thrift.TException {
+ isTableEnabled_result result = new isTableEnabled_result();
+ try {
+ result.success = iface.isTableEnabled(args.tableName);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class compact<I extends Iface> extends org.apache.thrift.ProcessFunction<I, compact_args> {
+ public compact() {
+ super("compact");
+ }
+
+ public compact_args getEmptyArgsInstance() {
+ return new compact_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public compact_result getResult(I iface, compact_args args) throws org.apache.thrift.TException {
+ compact_result result = new compact_result();
+ try {
+ iface.compact(args.tableNameOrRegionName);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class majorCompact<I extends Iface> extends org.apache.thrift.ProcessFunction<I, majorCompact_args> {
+ public majorCompact() {
+ super("majorCompact");
+ }
+
+ public majorCompact_args getEmptyArgsInstance() {
+ return new majorCompact_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public majorCompact_result getResult(I iface, majorCompact_args args) throws org.apache.thrift.TException {
+ majorCompact_result result = new majorCompact_result();
+ try {
+ iface.majorCompact(args.tableNameOrRegionName);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableNames<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableNames_args> {
+ public getTableNames() {
+ super("getTableNames");
+ }
+
+ public getTableNames_args getEmptyArgsInstance() {
+ return new getTableNames_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableNames_result getResult(I iface, getTableNames_args args) throws org.apache.thrift.TException {
+ getTableNames_result result = new getTableNames_result();
+ try {
+ result.success = iface.getTableNames();
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableNamesWithIsTableEnabled<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableNamesWithIsTableEnabled_args> {
+ public getTableNamesWithIsTableEnabled() {
+ super("getTableNamesWithIsTableEnabled");
+ }
+
+ public getTableNamesWithIsTableEnabled_args getEmptyArgsInstance() {
+ return new getTableNamesWithIsTableEnabled_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableNamesWithIsTableEnabled_result getResult(I iface, getTableNamesWithIsTableEnabled_args args) throws org.apache.thrift.TException {
+ getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result();
+ try {
+ result.success = iface.getTableNamesWithIsTableEnabled();
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getColumnDescriptors<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getColumnDescriptors_args> {
+ public getColumnDescriptors() {
+ super("getColumnDescriptors");
+ }
+
+ public getColumnDescriptors_args getEmptyArgsInstance() {
+ return new getColumnDescriptors_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getColumnDescriptors_result getResult(I iface, getColumnDescriptors_args args) throws org.apache.thrift.TException {
+ getColumnDescriptors_result result = new getColumnDescriptors_result();
+ try {
+ result.success = iface.getColumnDescriptors(args.tableName);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableRegions<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableRegions_args> {
+ public getTableRegions() {
+ super("getTableRegions");
+ }
+
+ public getTableRegions_args getEmptyArgsInstance() {
+ return new getTableRegions_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableRegions_result getResult(I iface, getTableRegions_args args) throws org.apache.thrift.TException {
+ getTableRegions_result result = new getTableRegions_result();
+ try {
+ result.success = iface.getTableRegions(args.tableName);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class createTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createTable_args> {
+ public createTable() {
+ super("createTable");
+ }
+
+ public createTable_args getEmptyArgsInstance() {
+ return new createTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public createTable_result getResult(I iface, createTable_args args) throws org.apache.thrift.TException {
+ createTable_result result = new createTable_result();
+ try {
+ iface.createTable(args.tableName, args.columnFamilies);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ } catch (AlreadyExists exist) {
+ result.exist = exist;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteTable_args> {
+ public deleteTable() {
+ super("deleteTable");
+ }
+
+ public deleteTable_args getEmptyArgsInstance() {
+ return new deleteTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteTable_result getResult(I iface, deleteTable_args args) throws org.apache.thrift.TException {
+ deleteTable_result result = new deleteTable_result();
+ try {
+ iface.deleteTable(args.tableName);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
+ public get() {
+ super("get");
+ }
+
+ public get_args getEmptyArgsInstance() {
+ return new get_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
+ get_result result = new get_result();
+ try {
+ result.success = iface.get(args.tableName, args.row, args.column, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getVer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getVer_args> {
+ public getVer() {
+ super("getVer");
+ }
+
+ public getVer_args getEmptyArgsInstance() {
+ return new getVer_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getVer_result getResult(I iface, getVer_args args) throws org.apache.thrift.TException {
+ getVer_result result = new getVer_result();
+ try {
+ result.success = iface.getVer(args.tableName, args.row, args.column, args.numVersions, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getVerTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getVerTs_args> {
+ public getVerTs() {
+ super("getVerTs");
+ }
+
+ public getVerTs_args getEmptyArgsInstance() {
+ return new getVerTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getVerTs_result getResult(I iface, getVerTs_args args) throws org.apache.thrift.TException {
+ getVerTs_result result = new getVerTs_result();
+ try {
+ result.success = iface.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRow_args> {
+ public getRow() {
+ super("getRow");
+ }
+
+ public getRow_args getEmptyArgsInstance() {
+ return new getRow_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRow_result getResult(I iface, getRow_args args) throws org.apache.thrift.TException {
+ getRow_result result = new getRow_result();
+ try {
+ result.success = iface.getRow(args.tableName, args.row, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRowWithColumns<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRowWithColumns_args> {
+ public getRowWithColumns() {
+ super("getRowWithColumns");
+ }
+
+ public getRowWithColumns_args getEmptyArgsInstance() {
+ return new getRowWithColumns_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRowWithColumns_result getResult(I iface, getRowWithColumns_args args) throws org.apache.thrift.TException {
+ getRowWithColumns_result result = new getRowWithColumns_result();
+ try {
+ result.success = iface.getRowWithColumns(args.tableName, args.row, args.columns, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRowTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRowTs_args> {
+ public getRowTs() {
+ super("getRowTs");
+ }
+
+ public getRowTs_args getEmptyArgsInstance() {
+ return new getRowTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRowTs_result getResult(I iface, getRowTs_args args) throws org.apache.thrift.TException {
+ getRowTs_result result = new getRowTs_result();
+ try {
+ result.success = iface.getRowTs(args.tableName, args.row, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRowWithColumnsTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRowWithColumnsTs_args> {
+ public getRowWithColumnsTs() {
+ super("getRowWithColumnsTs");
+ }
+
+ public getRowWithColumnsTs_args getEmptyArgsInstance() {
+ return new getRowWithColumnsTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRowWithColumnsTs_result getResult(I iface, getRowWithColumnsTs_args args) throws org.apache.thrift.TException {
+ getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
+ try {
+ result.success = iface.getRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRows_args> {
+ public getRows() {
+ super("getRows");
+ }
+
+ public getRows_args getEmptyArgsInstance() {
+ return new getRows_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRows_result getResult(I iface, getRows_args args) throws org.apache.thrift.TException {
+ getRows_result result = new getRows_result();
+ try {
+ result.success = iface.getRows(args.tableName, args.rows, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRowsWithColumns<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRowsWithColumns_args> {
+ public getRowsWithColumns() {
+ super("getRowsWithColumns");
+ }
+
+ public getRowsWithColumns_args getEmptyArgsInstance() {
+ return new getRowsWithColumns_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRowsWithColumns_result getResult(I iface, getRowsWithColumns_args args) throws org.apache.thrift.TException {
+ getRowsWithColumns_result result = new getRowsWithColumns_result();
+ try {
+ result.success = iface.getRowsWithColumns(args.tableName, args.rows, args.columns, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRowsTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRowsTs_args> {
+ public getRowsTs() {
+ super("getRowsTs");
+ }
+
+ public getRowsTs_args getEmptyArgsInstance() {
+ return new getRowsTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRowsTs_result getResult(I iface, getRowsTs_args args) throws org.apache.thrift.TException {
+ getRowsTs_result result = new getRowsTs_result();
+ try {
+ result.success = iface.getRowsTs(args.tableName, args.rows, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRowsWithColumnsTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRowsWithColumnsTs_args> {
+ public getRowsWithColumnsTs() {
+ super("getRowsWithColumnsTs");
+ }
+
+ public getRowsWithColumnsTs_args getEmptyArgsInstance() {
+ return new getRowsWithColumnsTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRowsWithColumnsTs_result getResult(I iface, getRowsWithColumnsTs_args args) throws org.apache.thrift.TException {
+ getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
+ try {
+ result.success = iface.getRowsWithColumnsTs(args.tableName, args.rows, args.columns, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class mutateRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRow_args> {
+ public mutateRow() {
+ super("mutateRow");
+ }
+
+ public mutateRow_args getEmptyArgsInstance() {
+ return new mutateRow_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public mutateRow_result getResult(I iface, mutateRow_args args) throws org.apache.thrift.TException {
+ mutateRow_result result = new mutateRow_result();
+ try {
+ iface.mutateRow(args.tableName, args.row, args.mutations, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class mutateRowTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRowTs_args> {
+ public mutateRowTs() {
+ super("mutateRowTs");
+ }
+
+ public mutateRowTs_args getEmptyArgsInstance() {
+ return new mutateRowTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public mutateRowTs_result getResult(I iface, mutateRowTs_args args) throws org.apache.thrift.TException {
+ mutateRowTs_result result = new mutateRowTs_result();
+ try {
+ iface.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class mutateRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRows_args> {
+ public mutateRows() {
+ super("mutateRows");
+ }
+
+ public mutateRows_args getEmptyArgsInstance() {
+ return new mutateRows_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public mutateRows_result getResult(I iface, mutateRows_args args) throws org.apache.thrift.TException {
+ mutateRows_result result = new mutateRows_result();
+ try {
+ iface.mutateRows(args.tableName, args.rowBatches, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class mutateRowsTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRowsTs_args> {
+ public mutateRowsTs() {
+ super("mutateRowsTs");
+ }
+
+ public mutateRowsTs_args getEmptyArgsInstance() {
+ return new mutateRowsTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public mutateRowsTs_result getResult(I iface, mutateRowsTs_args args) throws org.apache.thrift.TException {
+ mutateRowsTs_result result = new mutateRowsTs_result();
+ try {
+ iface.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class atomicIncrement<I extends Iface> extends org.apache.thrift.ProcessFunction<I, atomicIncrement_args> {
+ public atomicIncrement() {
+ super("atomicIncrement");
+ }
+
+ public atomicIncrement_args getEmptyArgsInstance() {
+ return new atomicIncrement_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public atomicIncrement_result getResult(I iface, atomicIncrement_args args) throws org.apache.thrift.TException {
+ atomicIncrement_result result = new atomicIncrement_result();
+ try {
+ result.success = iface.atomicIncrement(args.tableName, args.row, args.column, args.value);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteAll<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteAll_args> {
+ public deleteAll() {
+ super("deleteAll");
+ }
+
+ public deleteAll_args getEmptyArgsInstance() {
+ return new deleteAll_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteAll_result getResult(I iface, deleteAll_args args) throws org.apache.thrift.TException {
+ deleteAll_result result = new deleteAll_result();
+ try {
+ iface.deleteAll(args.tableName, args.row, args.column, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteAllTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteAllTs_args> {
+ public deleteAllTs() {
+ super("deleteAllTs");
+ }
+
+ public deleteAllTs_args getEmptyArgsInstance() {
+ return new deleteAllTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteAllTs_result getResult(I iface, deleteAllTs_args args) throws org.apache.thrift.TException {
+ deleteAllTs_result result = new deleteAllTs_result();
+ try {
+ iface.deleteAllTs(args.tableName, args.row, args.column, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteAllRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteAllRow_args> {
+ public deleteAllRow() {
+ super("deleteAllRow");
+ }
+
+ public deleteAllRow_args getEmptyArgsInstance() {
+ return new deleteAllRow_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteAllRow_result getResult(I iface, deleteAllRow_args args) throws org.apache.thrift.TException {
+ deleteAllRow_result result = new deleteAllRow_result();
+ try {
+ iface.deleteAllRow(args.tableName, args.row, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
+ public increment() {
+ super("increment");
+ }
+
+ public increment_args getEmptyArgsInstance() {
+ return new increment_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
+ increment_result result = new increment_result();
+ try {
+ iface.increment(args.increment);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class incrementRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, incrementRows_args> {
+ public incrementRows() {
+ super("incrementRows");
+ }
+
+ public incrementRows_args getEmptyArgsInstance() {
+ return new incrementRows_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public incrementRows_result getResult(I iface, incrementRows_args args) throws org.apache.thrift.TException {
+ incrementRows_result result = new incrementRows_result();
+ try {
+ iface.incrementRows(args.increments);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteAllRowTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteAllRowTs_args> {
+ public deleteAllRowTs() {
+ super("deleteAllRowTs");
+ }
+
+ public deleteAllRowTs_args getEmptyArgsInstance() {
+ return new deleteAllRowTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteAllRowTs_result getResult(I iface, deleteAllRowTs_args args) throws org.apache.thrift.TException {
+ deleteAllRowTs_result result = new deleteAllRowTs_result();
+ try {
+ iface.deleteAllRowTs(args.tableName, args.row, args.timestamp, args.attributes);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerOpenWithScan<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerOpenWithScan_args> {
+ public scannerOpenWithScan() {
+ super("scannerOpenWithScan");
+ }
+
+ public scannerOpenWithScan_args getEmptyArgsInstance() {
+ return new scannerOpenWithScan_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerOpenWithScan_result getResult(I iface, scannerOpenWithScan_args args) throws org.apache.thrift.TException {
+ scannerOpenWithScan_result result = new scannerOpenWithScan_result();
+ try {
+ result.success = iface.scannerOpenWithScan(args.tableName, args.scan, args.attributes);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerOpen<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerOpen_args> {
+ public scannerOpen() {
+ super("scannerOpen");
+ }
+
+ public scannerOpen_args getEmptyArgsInstance() {
+ return new scannerOpen_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerOpen_result getResult(I iface, scannerOpen_args args) throws org.apache.thrift.TException {
+ scannerOpen_result result = new scannerOpen_result();
+ try {
+ result.success = iface.scannerOpen(args.tableName, args.startRow, args.columns, args.attributes);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerOpenWithStop<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerOpenWithStop_args> {
+ public scannerOpenWithStop() {
+ super("scannerOpenWithStop");
+ }
+
+ public scannerOpenWithStop_args getEmptyArgsInstance() {
+ return new scannerOpenWithStop_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerOpenWithStop_result getResult(I iface, scannerOpenWithStop_args args) throws org.apache.thrift.TException {
+ scannerOpenWithStop_result result = new scannerOpenWithStop_result();
+ try {
+ result.success = iface.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns, args.attributes);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerOpenWithPrefix<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerOpenWithPrefix_args> {
+ public scannerOpenWithPrefix() {
+ super("scannerOpenWithPrefix");
+ }
+
+ public scannerOpenWithPrefix_args getEmptyArgsInstance() {
+ return new scannerOpenWithPrefix_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerOpenWithPrefix_result getResult(I iface, scannerOpenWithPrefix_args args) throws org.apache.thrift.TException {
+ scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
+ try {
+ result.success = iface.scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns, args.attributes);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerOpenTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerOpenTs_args> {
+ public scannerOpenTs() {
+ super("scannerOpenTs");
+ }
+
+ public scannerOpenTs_args getEmptyArgsInstance() {
+ return new scannerOpenTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerOpenTs_result getResult(I iface, scannerOpenTs_args args) throws org.apache.thrift.TException {
+ scannerOpenTs_result result = new scannerOpenTs_result();
+ try {
+ result.success = iface.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp, args.attributes);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerOpenWithStopTs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerOpenWithStopTs_args> {
+ public scannerOpenWithStopTs() {
+ super("scannerOpenWithStopTs");
+ }
+
+ public scannerOpenWithStopTs_args getEmptyArgsInstance() {
+ return new scannerOpenWithStopTs_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerOpenWithStopTs_result getResult(I iface, scannerOpenWithStopTs_args args) throws org.apache.thrift.TException {
+ scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
+ try {
+ result.success = iface.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp, args.attributes);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerGet<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerGet_args> {
+ public scannerGet() {
+ super("scannerGet");
+ }
+
+ public scannerGet_args getEmptyArgsInstance() {
+ return new scannerGet_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerGet_result getResult(I iface, scannerGet_args args) throws org.apache.thrift.TException {
+ scannerGet_result result = new scannerGet_result();
+ try {
+ result.success = iface.scannerGet(args.id);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerGetList<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerGetList_args> {
+ public scannerGetList() {
+ super("scannerGetList");
+ }
+
+ public scannerGetList_args getEmptyArgsInstance() {
+ return new scannerGetList_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerGetList_result getResult(I iface, scannerGetList_args args) throws org.apache.thrift.TException {
+ scannerGetList_result result = new scannerGetList_result();
+ try {
+ result.success = iface.scannerGetList(args.id, args.nbRows);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class scannerClose<I extends Iface> extends org.apache.thrift.ProcessFunction<I, scannerClose_args> {
+ public scannerClose() {
+ super("scannerClose");
+ }
+
+ public scannerClose_args getEmptyArgsInstance() {
+ return new scannerClose_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public scannerClose_result getResult(I iface, scannerClose_args args) throws org.apache.thrift.TException {
+ scannerClose_result result = new scannerClose_result();
+ try {
+ iface.scannerClose(args.id);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class getRegionInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRegionInfo_args> {
+ public getRegionInfo() {
+ super("getRegionInfo");
+ }
+
+ public getRegionInfo_args getEmptyArgsInstance() {
+ return new getRegionInfo_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRegionInfo_result getResult(I iface, getRegionInfo_args args) throws org.apache.thrift.TException {
+ getRegionInfo_result result = new getRegionInfo_result();
+ try {
+ result.success = iface.getRegionInfo(args.row);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class append<I extends Iface> extends org.apache.thrift.ProcessFunction<I, append_args> {
+ public append() {
+ super("append");
+ }
+
+ public append_args getEmptyArgsInstance() {
+ return new append_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public append_result getResult(I iface, append_args args) throws org.apache.thrift.TException {
+ append_result result = new append_result();
+ try {
+ result.success = iface.append(args.append);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
+ public checkAndPut() {
+ super("checkAndPut");
+ }
+
+ public checkAndPut_args getEmptyArgsInstance() {
+ return new checkAndPut_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
+ checkAndPut_result result = new checkAndPut_result();
+ try {
+ result.success = iface.checkAndPut(args.tableName, args.row, args.column, args.value, args.mput, args.attributes);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class getThriftServerType<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getThriftServerType_args> {
+ public getThriftServerType() {
+ super("getThriftServerType");
+ }
+
+ public getThriftServerType_args getEmptyArgsInstance() {
+ return new getThriftServerType_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getThriftServerType_result getResult(I iface, getThriftServerType_args args) throws org.apache.thrift.TException {
+ getThriftServerType_result result = new getThriftServerType_result();
+ result.success = iface.getThriftServerType();
+ return result;
+ }
+ }
+
+ public static class getClusterId<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getClusterId_args> {
+ public getClusterId() {
+ super("getClusterId");
+ }
+
+ public getClusterId_args getEmptyArgsInstance() {
+ return new getClusterId_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getClusterId_result getResult(I iface, getClusterId_args args) throws org.apache.thrift.TException {
+ getClusterId_result result = new getClusterId_result();
+ result.success = iface.getClusterId();
+ return result;
+ }
+ }
+
+ public static class grant<I extends Iface> extends org.apache.thrift.ProcessFunction<I, grant_args> {
+ public grant() {
+ super("grant");
+ }
+
+ public grant_args getEmptyArgsInstance() {
+ return new grant_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public grant_result getResult(I iface, grant_args args) throws org.apache.thrift.TException {
+ grant_result result = new grant_result();
+ try {
+ result.success = iface.grant(args.info);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class revoke<I extends Iface> extends org.apache.thrift.ProcessFunction<I, revoke_args> {
+ public revoke() {
+ super("revoke");
+ }
+
+ public revoke_args getEmptyArgsInstance() {
+ return new revoke_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public revoke_result getResult(I iface, revoke_args args) throws org.apache.thrift.TException {
+ revoke_result result = new revoke_result();
+ try {
+ result.success = iface.revoke(args.info);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ }
+
+ public static class AsyncProcessor<I extends AsyncIface> extends org.apache.thrift.TBaseAsyncProcessor<I> {
+ private static final org.slf4j.Logger _LOGGER = org.slf4j.LoggerFactory.getLogger(AsyncProcessor.class.getName());
+ public AsyncProcessor(I iface) {
+ super(iface, getProcessMap(new java.util.HashMap<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>>()));
+ }
+
+ protected AsyncProcessor(I iface, java.util.Map<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>> processMap) {
+ super(iface, getProcessMap(processMap));
+ }
+
+ private static <I extends AsyncIface> java.util.Map<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase,?>> getProcessMap(java.util.Map<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>> processMap) {
+ processMap.put("enableTable", new enableTable());
+ processMap.put("disableTable", new disableTable());
+ processMap.put("isTableEnabled", new isTableEnabled());
+ processMap.put("compact", new compact());
+ processMap.put("majorCompact", new majorCompact());
+ processMap.put("getTableNames", new getTableNames());
+ processMap.put("getTableNamesWithIsTableEnabled", new getTableNamesWithIsTableEnabled());
+ processMap.put("getColumnDescriptors", new getColumnDescriptors());
+ processMap.put("getTableRegions", new getTableRegions());
+ processMap.put("createTable", new createTable());
+ processMap.put("deleteTable", new deleteTable());
+ processMap.put("get", new get());
+ processMap.put("getVer", new getVer());
+ processMap.put("getVerTs", new getVerTs());
+ processMap.put("getRow", new getRow());
+ processMap.put("getRowWithColumns", new getRowWithColumns());
+ processMap.put("getRowTs", new getRowTs());
+ processMap.put("getRowWithColumnsTs", new getRowWithColumnsTs());
+ processMap.put("getRows", new getRows());
+ processMap.put("getRowsWithColumns", new getRowsWithColumns());
+ processMap.put("getRowsTs", new getRowsTs());
+ processMap.put("getRowsWithColumnsTs", new getRowsWithColumnsTs());
+ processMap.put("mutateRow", new mutateRow());
+ processMap.put("mutateRowTs", new mutateRowTs());
+ processMap.put("mutateRows", new mutateRows());
+ processMap.put("mutateRowsTs", new mutateRowsTs());
+ processMap.put("atomicIncrement", new atomicIncrement());
+ processMap.put("deleteAll", new deleteAll());
+ processMap.put("deleteAllTs", new deleteAllTs());
+ processMap.put("deleteAllRow", new deleteAllRow());
+ processMap.put("increment", new increment());
+ processMap.put("incrementRows", new incrementRows());
+ processMap.put("deleteAllRowTs", new deleteAllRowTs());
+ processMap.put("scannerOpenWithScan", new scannerOpenWithScan());
+ processMap.put("scannerOpen", new scannerOpen());
+ processMap.put("scannerOpenWithStop", new scannerOpenWithStop());
+ processMap.put("scannerOpenWithPrefix", new scannerOpenWithPrefix());
+ processMap.put("scannerOpenTs", new scannerOpenTs());
+ processMap.put("scannerOpenWithStopTs", new scannerOpenWithStopTs());
+ processMap.put("scannerGet", new scannerGet());
+ processMap.put("scannerGetList", new scannerGetList());
+ processMap.put("scannerClose", new scannerClose());
+ processMap.put("getRegionInfo", new getRegionInfo());
+ processMap.put("append", new append());
+ processMap.put("checkAndPut", new checkAndPut());
+ processMap.put("getThriftServerType", new getThriftServerType());
+ processMap.put("getClusterId", new getClusterId());
+ processMap.put("grant", new grant());
+ processMap.put("revoke", new revoke());
+ return processMap;
+ }
+
+ public static class enableTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, enableTable_args, Void> {
+ public enableTable() {
+ super("enableTable");
+ }
+
+ public enableTable_args getEmptyArgsInstance() {
+ return new enableTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ enableTable_result result = new enableTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ enableTable_result result = new enableTable_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, enableTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.enableTable(args.tableName,resultHandler);
+ }
+ }
+
+ public static class disableTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, disableTable_args, Void> {
+ public disableTable() {
+ super("disableTable");
+ }
+
+ public disableTable_args getEmptyArgsInstance() {
+ return new disableTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ disableTable_result result = new disableTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ disableTable_result result = new disableTable_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, disableTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.disableTable(args.tableName,resultHandler);
+ }
+ }
+
+ public static class isTableEnabled<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isTableEnabled_args, java.lang.Boolean> {
+ public isTableEnabled() {
+ super("isTableEnabled");
+ }
+
+ public isTableEnabled_args getEmptyArgsInstance() {
+ return new isTableEnabled_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ isTableEnabled_result result = new isTableEnabled_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ isTableEnabled_result result = new isTableEnabled_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, isTableEnabled_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.isTableEnabled(args.tableName,resultHandler);
+ }
+ }
+
+ public static class compact<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, compact_args, Void> {
+ public compact() {
+ super("compact");
+ }
+
+ public compact_args getEmptyArgsInstance() {
+ return new compact_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ compact_result result = new compact_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ compact_result result = new compact_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, compact_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.compact(args.tableNameOrRegionName,resultHandler);
+ }
+ }
+
+ public static class majorCompact<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, majorCompact_args, Void> {
+ public majorCompact() {
+ super("majorCompact");
+ }
+
+ public majorCompact_args getEmptyArgsInstance() {
+ return new majorCompact_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ majorCompact_result result = new majorCompact_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ majorCompact_result result = new majorCompact_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, majorCompact_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.majorCompact(args.tableNameOrRegionName,resultHandler);
+ }
+ }
+
+ public static class getTableNames<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableNames_args, java.util.List<java.nio.ByteBuffer>> {
+ public getTableNames() {
+ super("getTableNames");
+ }
+
+ public getTableNames_args getEmptyArgsInstance() {
+ return new getTableNames_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.nio.ByteBuffer>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.nio.ByteBuffer>>() {
+ public void onComplete(java.util.List<java.nio.ByteBuffer> o) {
+ getTableNames_result result = new getTableNames_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableNames_result result = new getTableNames_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableNames_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.nio.ByteBuffer>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableNames(resultHandler);
+ }
+ }
+
+ public static class getTableNamesWithIsTableEnabled<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableNamesWithIsTableEnabled_args, java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>> {
+ public getTableNamesWithIsTableEnabled() {
+ super("getTableNamesWithIsTableEnabled");
+ }
+
+ public getTableNamesWithIsTableEnabled_args getEmptyArgsInstance() {
+ return new getTableNamesWithIsTableEnabled_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>>() {
+ public void onComplete(java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> o) {
+ getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableNamesWithIsTableEnabled_result result = new getTableNamesWithIsTableEnabled_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableNamesWithIsTableEnabled_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableNamesWithIsTableEnabled(resultHandler);
+ }
+ }
+
+ public static class getColumnDescriptors<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getColumnDescriptors_args, java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>> {
+ public getColumnDescriptors() {
+ super("getColumnDescriptors");
+ }
+
+ public getColumnDescriptors_args getEmptyArgsInstance() {
+ return new getColumnDescriptors_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>>() {
+ public void onComplete(java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> o) {
+ getColumnDescriptors_result result = new getColumnDescriptors_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getColumnDescriptors_result result = new getColumnDescriptors_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getColumnDescriptors_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ iface.getColumnDescriptors(args.tableName,resultHandler);
+ }
+ }
+
+ public static class getTableRegions<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableRegions_args, java.util.List<TRegionInfo>> {
+ public getTableRegions() {
+ super("getTableRegions");
+ }
+
+ public getTableRegions_args getEmptyArgsInstance() {
+ return new getTableRegions_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRegionInfo>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRegionInfo>>() {
+ public void onComplete(java.util.List<TRegionInfo> o) {
+ getTableRegions_result result = new getTableRegions_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableRegions_result result = new getTableRegions_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableRegions_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRegionInfo>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableRegions(args.tableName,resultHandler);
+ }
+ }
+
+ public static class createTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, createTable_args, Void> {
+ public createTable() {
+ super("createTable");
+ }
+
+ public createTable_args getEmptyArgsInstance() {
+ return new createTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ createTable_result result = new createTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ createTable_result result = new createTable_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof AlreadyExists) {
+ result.exist = (AlreadyExists) e;
+ result.setExistIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, createTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.createTable(args.tableName, args.columnFamilies,resultHandler);
+ }
+ }
+
+ public static class deleteTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteTable_args, Void> {
+ public deleteTable() {
+ super("deleteTable");
+ }
+
+ public deleteTable_args getEmptyArgsInstance() {
+ return new deleteTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteTable_result result = new deleteTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteTable_result result = new deleteTable_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteTable(args.tableName,resultHandler);
+ }
+ }
+
+ public static class get<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, get_args, java.util.List<TCell>> {
+ public get() {
+ super("get");
+ }
+
+ public get_args getEmptyArgsInstance() {
+ return new get_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>>() {
+ public void onComplete(java.util.List<TCell> o) {
+ get_result result = new get_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ get_result result = new get_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, get_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ iface.get(args.tableName, args.row, args.column, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getVer<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getVer_args, java.util.List<TCell>> {
+ public getVer() {
+ super("getVer");
+ }
+
+ public getVer_args getEmptyArgsInstance() {
+ return new getVer_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>>() {
+ public void onComplete(java.util.List<TCell> o) {
+ getVer_result result = new getVer_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getVer_result result = new getVer_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getVer_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ iface.getVer(args.tableName, args.row, args.column, args.numVersions, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getVerTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getVerTs_args, java.util.List<TCell>> {
+ public getVerTs() {
+ super("getVerTs");
+ }
+
+ public getVerTs_args getEmptyArgsInstance() {
+ return new getVerTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>>() {
+ public void onComplete(java.util.List<TCell> o) {
+ getVerTs_result result = new getVerTs_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getVerTs_result result = new getVerTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getVerTs_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ iface.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRow<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRow_args, java.util.List<TRowResult>> {
+ public getRow() {
+ super("getRow");
+ }
+
+ public getRow_args getEmptyArgsInstance() {
+ return new getRow_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRow_result result = new getRow_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRow_result result = new getRow_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRow_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRow(args.tableName, args.row, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRowWithColumns<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRowWithColumns_args, java.util.List<TRowResult>> {
+ public getRowWithColumns() {
+ super("getRowWithColumns");
+ }
+
+ public getRowWithColumns_args getEmptyArgsInstance() {
+ return new getRowWithColumns_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRowWithColumns_result result = new getRowWithColumns_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRowWithColumns_result result = new getRowWithColumns_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRowWithColumns_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRowWithColumns(args.tableName, args.row, args.columns, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRowTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRowTs_args, java.util.List<TRowResult>> {
+ public getRowTs() {
+ super("getRowTs");
+ }
+
+ public getRowTs_args getEmptyArgsInstance() {
+ return new getRowTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRowTs_result result = new getRowTs_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRowTs_result result = new getRowTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRowTs_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRowTs(args.tableName, args.row, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRowWithColumnsTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRowWithColumnsTs_args, java.util.List<TRowResult>> {
+ public getRowWithColumnsTs() {
+ super("getRowWithColumnsTs");
+ }
+
+ public getRowWithColumnsTs_args getEmptyArgsInstance() {
+ return new getRowWithColumnsTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRowWithColumnsTs_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRows<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRows_args, java.util.List<TRowResult>> {
+ public getRows() {
+ super("getRows");
+ }
+
+ public getRows_args getEmptyArgsInstance() {
+ return new getRows_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRows_result result = new getRows_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRows_result result = new getRows_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRows_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRows(args.tableName, args.rows, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRowsWithColumns<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRowsWithColumns_args, java.util.List<TRowResult>> {
+ public getRowsWithColumns() {
+ super("getRowsWithColumns");
+ }
+
+ public getRowsWithColumns_args getEmptyArgsInstance() {
+ return new getRowsWithColumns_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRowsWithColumns_result result = new getRowsWithColumns_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRowsWithColumns_result result = new getRowsWithColumns_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRowsWithColumns_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRowsWithColumns(args.tableName, args.rows, args.columns, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRowsTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRowsTs_args, java.util.List<TRowResult>> {
+ public getRowsTs() {
+ super("getRowsTs");
+ }
+
+ public getRowsTs_args getEmptyArgsInstance() {
+ return new getRowsTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRowsTs_result result = new getRowsTs_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRowsTs_result result = new getRowsTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRowsTs_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRowsTs(args.tableName, args.rows, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getRowsWithColumnsTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRowsWithColumnsTs_args, java.util.List<TRowResult>> {
+ public getRowsWithColumnsTs() {
+ super("getRowsWithColumnsTs");
+ }
+
+ public getRowsWithColumnsTs_args getEmptyArgsInstance() {
+ return new getRowsWithColumnsTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRowsWithColumnsTs_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getRowsWithColumnsTs(args.tableName, args.rows, args.columns, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class mutateRow<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, mutateRow_args, Void> {
+ public mutateRow() {
+ super("mutateRow");
+ }
+
+ public mutateRow_args getEmptyArgsInstance() {
+ return new mutateRow_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ mutateRow_result result = new mutateRow_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ mutateRow_result result = new mutateRow_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, mutateRow_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.mutateRow(args.tableName, args.row, args.mutations, args.attributes,resultHandler);
+ }
+ }
+
+ public static class mutateRowTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, mutateRowTs_args, Void> {
+ public mutateRowTs() {
+ super("mutateRowTs");
+ }
+
+ public mutateRowTs_args getEmptyArgsInstance() {
+ return new mutateRowTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ mutateRowTs_result result = new mutateRowTs_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ mutateRowTs_result result = new mutateRowTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, mutateRowTs_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class mutateRows<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, mutateRows_args, Void> {
+ public mutateRows() {
+ super("mutateRows");
+ }
+
+ public mutateRows_args getEmptyArgsInstance() {
+ return new mutateRows_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ mutateRows_result result = new mutateRows_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ mutateRows_result result = new mutateRows_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, mutateRows_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.mutateRows(args.tableName, args.rowBatches, args.attributes,resultHandler);
+ }
+ }
+
+ public static class mutateRowsTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, mutateRowsTs_args, Void> {
+ public mutateRowsTs() {
+ super("mutateRowsTs");
+ }
+
+ public mutateRowsTs_args getEmptyArgsInstance() {
+ return new mutateRowsTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ mutateRowsTs_result result = new mutateRowsTs_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ mutateRowsTs_result result = new mutateRowsTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, mutateRowsTs_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class atomicIncrement<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, atomicIncrement_args, java.lang.Long> {
+ public atomicIncrement() {
+ super("atomicIncrement");
+ }
+
+ public atomicIncrement_args getEmptyArgsInstance() {
+ return new atomicIncrement_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Long> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Long>() {
+ public void onComplete(java.lang.Long o) {
+ atomicIncrement_result result = new atomicIncrement_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ atomicIncrement_result result = new atomicIncrement_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, atomicIncrement_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Long> resultHandler) throws org.apache.thrift.TException {
+ iface.atomicIncrement(args.tableName, args.row, args.column, args.value,resultHandler);
+ }
+ }
+
+ public static class deleteAll<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteAll_args, Void> {
+ public deleteAll() {
+ super("deleteAll");
+ }
+
+ public deleteAll_args getEmptyArgsInstance() {
+ return new deleteAll_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteAll_result result = new deleteAll_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteAll_result result = new deleteAll_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteAll_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteAll(args.tableName, args.row, args.column, args.attributes,resultHandler);
+ }
+ }
+
+ public static class deleteAllTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteAllTs_args, Void> {
+ public deleteAllTs() {
+ super("deleteAllTs");
+ }
+
+ public deleteAllTs_args getEmptyArgsInstance() {
+ return new deleteAllTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteAllTs_result result = new deleteAllTs_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteAllTs_result result = new deleteAllTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteAllTs_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteAllTs(args.tableName, args.row, args.column, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class deleteAllRow<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteAllRow_args, Void> {
+ public deleteAllRow() {
+ super("deleteAllRow");
+ }
+
+ public deleteAllRow_args getEmptyArgsInstance() {
+ return new deleteAllRow_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteAllRow_result result = new deleteAllRow_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteAllRow_result result = new deleteAllRow_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteAllRow_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteAllRow(args.tableName, args.row, args.attributes,resultHandler);
+ }
+ }
+
+ public static class increment<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, increment_args, Void> {
+ public increment() {
+ super("increment");
+ }
+
+ public increment_args getEmptyArgsInstance() {
+ return new increment_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ increment_result result = new increment_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ increment_result result = new increment_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, increment_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.increment(args.increment,resultHandler);
+ }
+ }
+
+ public static class incrementRows<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, incrementRows_args, Void> {
+ public incrementRows() {
+ super("incrementRows");
+ }
+
+ public incrementRows_args getEmptyArgsInstance() {
+ return new incrementRows_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ incrementRows_result result = new incrementRows_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ incrementRows_result result = new incrementRows_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, incrementRows_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.incrementRows(args.increments,resultHandler);
+ }
+ }
+
+ public static class deleteAllRowTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteAllRowTs_args, Void> {
+ public deleteAllRowTs() {
+ super("deleteAllRowTs");
+ }
+
+ public deleteAllRowTs_args getEmptyArgsInstance() {
+ return new deleteAllRowTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteAllRowTs_result result = new deleteAllRowTs_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteAllRowTs_result result = new deleteAllRowTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteAllRowTs_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteAllRowTs(args.tableName, args.row, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class scannerOpenWithScan<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerOpenWithScan_args, java.lang.Integer> {
+ public scannerOpenWithScan() {
+ super("scannerOpenWithScan");
+ }
+
+ public scannerOpenWithScan_args getEmptyArgsInstance() {
+ return new scannerOpenWithScan_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer>() {
+ public void onComplete(java.lang.Integer o) {
+ scannerOpenWithScan_result result = new scannerOpenWithScan_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerOpenWithScan_result result = new scannerOpenWithScan_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerOpenWithScan_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerOpenWithScan(args.tableName, args.scan, args.attributes,resultHandler);
+ }
+ }
+
+ public static class scannerOpen<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerOpen_args, java.lang.Integer> {
+ public scannerOpen() {
+ super("scannerOpen");
+ }
+
+ public scannerOpen_args getEmptyArgsInstance() {
+ return new scannerOpen_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer>() {
+ public void onComplete(java.lang.Integer o) {
+ scannerOpen_result result = new scannerOpen_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerOpen_result result = new scannerOpen_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerOpen_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerOpen(args.tableName, args.startRow, args.columns, args.attributes,resultHandler);
+ }
+ }
+
+ public static class scannerOpenWithStop<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerOpenWithStop_args, java.lang.Integer> {
+ public scannerOpenWithStop() {
+ super("scannerOpenWithStop");
+ }
+
+ public scannerOpenWithStop_args getEmptyArgsInstance() {
+ return new scannerOpenWithStop_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer>() {
+ public void onComplete(java.lang.Integer o) {
+ scannerOpenWithStop_result result = new scannerOpenWithStop_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerOpenWithStop_result result = new scannerOpenWithStop_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerOpenWithStop_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns, args.attributes,resultHandler);
+ }
+ }
+
+ public static class scannerOpenWithPrefix<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerOpenWithPrefix_args, java.lang.Integer> {
+ public scannerOpenWithPrefix() {
+ super("scannerOpenWithPrefix");
+ }
+
+ public scannerOpenWithPrefix_args getEmptyArgsInstance() {
+ return new scannerOpenWithPrefix_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer>() {
+ public void onComplete(java.lang.Integer o) {
+ scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerOpenWithPrefix_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns, args.attributes,resultHandler);
+ }
+ }
+
+ public static class scannerOpenTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerOpenTs_args, java.lang.Integer> {
+ public scannerOpenTs() {
+ super("scannerOpenTs");
+ }
+
+ public scannerOpenTs_args getEmptyArgsInstance() {
+ return new scannerOpenTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer>() {
+ public void onComplete(java.lang.Integer o) {
+ scannerOpenTs_result result = new scannerOpenTs_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerOpenTs_result result = new scannerOpenTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerOpenTs_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class scannerOpenWithStopTs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerOpenWithStopTs_args, java.lang.Integer> {
+ public scannerOpenWithStopTs() {
+ super("scannerOpenWithStopTs");
+ }
+
+ public scannerOpenWithStopTs_args getEmptyArgsInstance() {
+ return new scannerOpenWithStopTs_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer>() {
+ public void onComplete(java.lang.Integer o) {
+ scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerOpenWithStopTs_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp, args.attributes,resultHandler);
+ }
+ }
+
+ public static class scannerGet<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerGet_args, java.util.List<TRowResult>> {
+ public scannerGet() {
+ super("scannerGet");
+ }
+
+ public scannerGet_args getEmptyArgsInstance() {
+ return new scannerGet_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ scannerGet_result result = new scannerGet_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerGet_result result = new scannerGet_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerGet_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerGet(args.id,resultHandler);
+ }
+ }
+
+ public static class scannerGetList<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerGetList_args, java.util.List<TRowResult>> {
+ public scannerGetList() {
+ super("scannerGetList");
+ }
+
+ public scannerGetList_args getEmptyArgsInstance() {
+ return new scannerGetList_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>>() {
+ public void onComplete(java.util.List<TRowResult> o) {
+ scannerGetList_result result = new scannerGetList_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerGetList_result result = new scannerGetList_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerGetList_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TRowResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerGetList(args.id, args.nbRows,resultHandler);
+ }
+ }
+
+ public static class scannerClose<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, scannerClose_args, Void> {
+ public scannerClose() {
+ super("scannerClose");
+ }
+
+ public scannerClose_args getEmptyArgsInstance() {
+ return new scannerClose_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ scannerClose_result result = new scannerClose_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ scannerClose_result result = new scannerClose_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, scannerClose_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.scannerClose(args.id,resultHandler);
+ }
+ }
+
+ public static class getRegionInfo<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRegionInfo_args, TRegionInfo> {
+ public getRegionInfo() {
+ super("getRegionInfo");
+ }
+
+ public getRegionInfo_args getEmptyArgsInstance() {
+ return new getRegionInfo_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TRegionInfo> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TRegionInfo>() {
+ public void onComplete(TRegionInfo o) {
+ getRegionInfo_result result = new getRegionInfo_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRegionInfo_result result = new getRegionInfo_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRegionInfo_args args, org.apache.thrift.async.AsyncMethodCallback<TRegionInfo> resultHandler) throws org.apache.thrift.TException {
+ iface.getRegionInfo(args.row,resultHandler);
+ }
+ }
+
+ public static class append<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, append_args, java.util.List<TCell>> {
+ public append() {
+ super("append");
+ }
+
+ public append_args getEmptyArgsInstance() {
+ return new append_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>>() {
+ public void onComplete(java.util.List<TCell> o) {
+ append_result result = new append_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ append_result result = new append_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, append_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TCell>> resultHandler) throws org.apache.thrift.TException {
+ iface.append(args.append,resultHandler);
+ }
+ }
+
+ public static class checkAndPut<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, checkAndPut_args, java.lang.Boolean> {
+ public checkAndPut() {
+ super("checkAndPut");
+ }
+
+ public checkAndPut_args getEmptyArgsInstance() {
+ return new checkAndPut_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ checkAndPut_result result = new checkAndPut_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ checkAndPut_result result = new checkAndPut_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof IllegalArgument) {
+ result.ia = (IllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, checkAndPut_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.checkAndPut(args.tableName, args.row, args.column, args.value, args.mput, args.attributes,resultHandler);
+ }
+ }
+
+ public static class getThriftServerType<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getThriftServerType_args, TThriftServerType> {
+ public getThriftServerType() {
+ super("getThriftServerType");
+ }
+
+ public getThriftServerType_args getEmptyArgsInstance() {
+ return new getThriftServerType_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TThriftServerType>() {
+ public void onComplete(TThriftServerType o) {
+ getThriftServerType_result result = new getThriftServerType_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getThriftServerType_result result = new getThriftServerType_result();
+ if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getThriftServerType_args args, org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler) throws org.apache.thrift.TException {
+ iface.getThriftServerType(resultHandler);
+ }
+ }
+
+ public static class getClusterId<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getClusterId_args, java.lang.String> {
+ public getClusterId() {
+ super("getClusterId");
+ }
+
+ public getClusterId_args getEmptyArgsInstance() {
+ return new getClusterId_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.String> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.String>() {
+ public void onComplete(java.lang.String o) {
+ getClusterId_result result = new getClusterId_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getClusterId_result result = new getClusterId_result();
+ if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getClusterId_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler) throws org.apache.thrift.TException {
+ iface.getClusterId(resultHandler);
+ }
+ }
+
+ public static class grant<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, grant_args, java.lang.Boolean> {
+ public grant() {
+ super("grant");
+ }
+
+ public grant_args getEmptyArgsInstance() {
+ return new grant_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ grant_result result = new grant_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ grant_result result = new grant_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, grant_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.grant(args.info,resultHandler);
+ }
+ }
+
+ public static class revoke<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, revoke_args, java.lang.Boolean> {
+ public revoke() {
+ super("revoke");
+ }
+
+ public revoke_args getEmptyArgsInstance() {
+ return new revoke_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ revoke_result result = new revoke_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ revoke_result result = new revoke_result();
+ if (e instanceof IOError) {
+ result.io = (IOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, revoke_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.revoke(args.info,resultHandler);
+ }
+ }
+
+ }
+
+ public static class enableTable_args implements org.apache.thrift.TBase<enableTable_args, enableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new enableTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new enableTable_argsTupleSchemeFactory();
+
+ /**
+ * name of the table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of the table
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap);
+ }
+
+ public enableTable_args() {
+ }
+
+ public enableTable_args(
+ java.nio.ByteBuffer tableName)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public enableTable_args(enableTable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ }
+
+ public enableTable_args deepCopy() {
+ return new enableTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * name of the table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of the table
+ */
+ public enableTable_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public enableTable_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof enableTable_args)
+ return this.equals((enableTable_args)that);
+ return false;
+ }
+
+ public boolean equals(enableTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(enableTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("enableTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class enableTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_argsStandardScheme getScheme() {
+ return new enableTable_argsStandardScheme();
+ }
+ }
+
+ private static class enableTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<enableTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, enableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, enableTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class enableTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_argsTupleScheme getScheme() {
+ return new enableTable_argsTupleScheme();
+ }
+ }
+
+ private static class enableTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<enableTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, enableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, enableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class enableTable_result implements org.apache.thrift.TBase<enableTable_result, enableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new enableTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new enableTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap);
+ }
+
+ public enableTable_result() {
+ }
+
+ public enableTable_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public enableTable_result(enableTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public enableTable_result deepCopy() {
+ return new enableTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public enableTable_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof enableTable_result)
+ return this.equals((enableTable_result)that);
+ return false;
+ }
+
+ public boolean equals(enableTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(enableTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("enableTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class enableTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_resultStandardScheme getScheme() {
+ return new enableTable_resultStandardScheme();
+ }
+ }
+
+ private static class enableTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<enableTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, enableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, enableTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class enableTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_resultTupleScheme getScheme() {
+ return new enableTable_resultTupleScheme();
+ }
+ }
+
+ private static class enableTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<enableTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, enableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, enableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class disableTable_args implements org.apache.thrift.TBase<disableTable_args, disableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new disableTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new disableTable_argsTupleSchemeFactory();
+
+ /**
+ * name of the table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of the table
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap);
+ }
+
+ public disableTable_args() {
+ }
+
+ public disableTable_args(
+ java.nio.ByteBuffer tableName)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public disableTable_args(disableTable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ }
+
+ public disableTable_args deepCopy() {
+ return new disableTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * name of the table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of the table
+ */
+ public disableTable_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public disableTable_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof disableTable_args)
+ return this.equals((disableTable_args)that);
+ return false;
+ }
+
+ public boolean equals(disableTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(disableTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("disableTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class disableTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_argsStandardScheme getScheme() {
+ return new disableTable_argsStandardScheme();
+ }
+ }
+
+ private static class disableTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<disableTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, disableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, disableTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class disableTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_argsTupleScheme getScheme() {
+ return new disableTable_argsTupleScheme();
+ }
+ }
+
+ private static class disableTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<disableTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, disableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, disableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class disableTable_result implements org.apache.thrift.TBase<disableTable_result, disableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new disableTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new disableTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap);
+ }
+
+ public disableTable_result() {
+ }
+
+ public disableTable_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public disableTable_result(disableTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public disableTable_result deepCopy() {
+ return new disableTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public disableTable_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof disableTable_result)
+ return this.equals((disableTable_result)that);
+ return false;
+ }
+
+ public boolean equals(disableTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(disableTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("disableTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class disableTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_resultStandardScheme getScheme() {
+ return new disableTable_resultStandardScheme();
+ }
+ }
+
+ private static class disableTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<disableTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, disableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, disableTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class disableTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_resultTupleScheme getScheme() {
+ return new disableTable_resultTupleScheme();
+ }
+ }
+
+ private static class disableTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<disableTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, disableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, disableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableEnabled_args implements org.apache.thrift.TBase<isTableEnabled_args, isTableEnabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableEnabled_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableEnabled_argsTupleSchemeFactory();
+
+ /**
+ * name of the table to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of the table to check
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap);
+ }
+
+ public isTableEnabled_args() {
+ }
+
+ public isTableEnabled_args(
+ java.nio.ByteBuffer tableName)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableEnabled_args(isTableEnabled_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ }
+
+ public isTableEnabled_args deepCopy() {
+ return new isTableEnabled_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * name of the table to check
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of the table to check
+ */
+ public isTableEnabled_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public isTableEnabled_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableEnabled_args)
+ return this.equals((isTableEnabled_args)that);
+ return false;
+ }
+
+ public boolean equals(isTableEnabled_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableEnabled_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableEnabled_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableEnabled_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_argsStandardScheme getScheme() {
+ return new isTableEnabled_argsStandardScheme();
+ }
+ }
+
+ private static class isTableEnabled_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableEnabled_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableEnabled_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_argsTupleScheme getScheme() {
+ return new isTableEnabled_argsTupleScheme();
+ }
+ }
+
+ private static class isTableEnabled_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableEnabled_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableEnabled_result implements org.apache.thrift.TBase<isTableEnabled_result, isTableEnabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableEnabled_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableEnabled_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap);
+ }
+
+ public isTableEnabled_result() {
+ }
+
+ public isTableEnabled_result(
+ boolean success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableEnabled_result(isTableEnabled_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public isTableEnabled_result deepCopy() {
+ return new isTableEnabled_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public isTableEnabled_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public isTableEnabled_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableEnabled_result)
+ return this.equals((isTableEnabled_result)that);
+ return false;
+ }
+
+ public boolean equals(isTableEnabled_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableEnabled_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableEnabled_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableEnabled_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_resultStandardScheme getScheme() {
+ return new isTableEnabled_resultStandardScheme();
+ }
+ }
+
+ private static class isTableEnabled_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableEnabled_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableEnabled_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_resultTupleScheme getScheme() {
+ return new isTableEnabled_resultTupleScheme();
+ }
+ }
+
+ private static class isTableEnabled_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableEnabled_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class compact_args implements org.apache.thrift.TBase<compact_args, compact_args._Fields>, java.io.Serializable, Cloneable, Comparable<compact_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new compact_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new compact_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableNameOrRegionName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME_OR_REGION_NAME
+ return TABLE_NAME_OR_REGION_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap);
+ }
+
+ public compact_args() {
+ }
+
+ public compact_args(
+ java.nio.ByteBuffer tableNameOrRegionName)
+ {
+ this();
+ this.tableNameOrRegionName = org.apache.thrift.TBaseHelper.copyBinary(tableNameOrRegionName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public compact_args(compact_args other) {
+ if (other.isSetTableNameOrRegionName()) {
+ this.tableNameOrRegionName = org.apache.thrift.TBaseHelper.copyBinary(other.tableNameOrRegionName);
+ }
+ }
+
+ public compact_args deepCopy() {
+ return new compact_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableNameOrRegionName = null;
+ }
+
+ public byte[] getTableNameOrRegionName() {
+ setTableNameOrRegionName(org.apache.thrift.TBaseHelper.rightSize(tableNameOrRegionName));
+ return tableNameOrRegionName == null ? null : tableNameOrRegionName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableNameOrRegionName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableNameOrRegionName);
+ }
+
+ public compact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
+ this.tableNameOrRegionName = tableNameOrRegionName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableNameOrRegionName.clone());
+ return this;
+ }
+
+ public compact_args setTableNameOrRegionName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableNameOrRegionName) {
+ this.tableNameOrRegionName = org.apache.thrift.TBaseHelper.copyBinary(tableNameOrRegionName);
+ return this;
+ }
+
+ public void unsetTableNameOrRegionName() {
+ this.tableNameOrRegionName = null;
+ }
+
+ /** Returns true if field tableNameOrRegionName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableNameOrRegionName() {
+ return this.tableNameOrRegionName != null;
+ }
+
+ public void setTableNameOrRegionNameIsSet(boolean value) {
+ if (!value) {
+ this.tableNameOrRegionName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME_OR_REGION_NAME:
+ if (value == null) {
+ unsetTableNameOrRegionName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableNameOrRegionName((byte[])value);
+ } else {
+ setTableNameOrRegionName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME_OR_REGION_NAME:
+ return getTableNameOrRegionName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME_OR_REGION_NAME:
+ return isSetTableNameOrRegionName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof compact_args)
+ return this.equals((compact_args)that);
+ return false;
+ }
+
+ public boolean equals(compact_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
+ boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
+ if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
+ if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
+ return false;
+ if (!this.tableNameOrRegionName.equals(that.tableNameOrRegionName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableNameOrRegionName()) ? 131071 : 524287);
+ if (isSetTableNameOrRegionName())
+ hashCode = hashCode * 8191 + tableNameOrRegionName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(compact_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableNameOrRegionName(), other.isSetTableNameOrRegionName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableNameOrRegionName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableNameOrRegionName, other.tableNameOrRegionName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("compact_args(");
+ boolean first = true;
+
+ sb.append("tableNameOrRegionName:");
+ if (this.tableNameOrRegionName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableNameOrRegionName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class compact_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public compact_argsStandardScheme getScheme() {
+ return new compact_argsStandardScheme();
+ }
+ }
+
+ private static class compact_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<compact_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, compact_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME_OR_REGION_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableNameOrRegionName = iprot.readBinary();
+ struct.setTableNameOrRegionNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, compact_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableNameOrRegionName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableNameOrRegionName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class compact_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public compact_argsTupleScheme getScheme() {
+ return new compact_argsTupleScheme();
+ }
+ }
+
+ private static class compact_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<compact_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, compact_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableNameOrRegionName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableNameOrRegionName()) {
+ oprot.writeBinary(struct.tableNameOrRegionName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, compact_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableNameOrRegionName = iprot.readBinary();
+ struct.setTableNameOrRegionNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class compact_result implements org.apache.thrift.TBase<compact_result, compact_result._Fields>, java.io.Serializable, Cloneable, Comparable<compact_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new compact_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new compact_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(compact_result.class, metaDataMap);
+ }
+
+ public compact_result() {
+ }
+
+ public compact_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public compact_result(compact_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public compact_result deepCopy() {
+ return new compact_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public compact_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof compact_result)
+ return this.equals((compact_result)that);
+ return false;
+ }
+
+ public boolean equals(compact_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(compact_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("compact_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class compact_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public compact_resultStandardScheme getScheme() {
+ return new compact_resultStandardScheme();
+ }
+ }
+
+ private static class compact_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<compact_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, compact_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, compact_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class compact_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public compact_resultTupleScheme getScheme() {
+ return new compact_resultTupleScheme();
+ }
+ }
+
+ private static class compact_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<compact_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, compact_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, compact_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class majorCompact_args implements org.apache.thrift.TBase<majorCompact_args, majorCompact_args._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new majorCompact_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new majorCompact_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableNameOrRegionName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME_OR_REGION_NAME
+ return TABLE_NAME_OR_REGION_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(majorCompact_args.class, metaDataMap);
+ }
+
+ public majorCompact_args() {
+ }
+
+ public majorCompact_args(
+ java.nio.ByteBuffer tableNameOrRegionName)
+ {
+ this();
+ this.tableNameOrRegionName = org.apache.thrift.TBaseHelper.copyBinary(tableNameOrRegionName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public majorCompact_args(majorCompact_args other) {
+ if (other.isSetTableNameOrRegionName()) {
+ this.tableNameOrRegionName = org.apache.thrift.TBaseHelper.copyBinary(other.tableNameOrRegionName);
+ }
+ }
+
+ public majorCompact_args deepCopy() {
+ return new majorCompact_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableNameOrRegionName = null;
+ }
+
+ public byte[] getTableNameOrRegionName() {
+ setTableNameOrRegionName(org.apache.thrift.TBaseHelper.rightSize(tableNameOrRegionName));
+ return tableNameOrRegionName == null ? null : tableNameOrRegionName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableNameOrRegionName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableNameOrRegionName);
+ }
+
+ public majorCompact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
+ this.tableNameOrRegionName = tableNameOrRegionName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableNameOrRegionName.clone());
+ return this;
+ }
+
+ public majorCompact_args setTableNameOrRegionName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableNameOrRegionName) {
+ this.tableNameOrRegionName = org.apache.thrift.TBaseHelper.copyBinary(tableNameOrRegionName);
+ return this;
+ }
+
+ public void unsetTableNameOrRegionName() {
+ this.tableNameOrRegionName = null;
+ }
+
+ /** Returns true if field tableNameOrRegionName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableNameOrRegionName() {
+ return this.tableNameOrRegionName != null;
+ }
+
+ public void setTableNameOrRegionNameIsSet(boolean value) {
+ if (!value) {
+ this.tableNameOrRegionName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME_OR_REGION_NAME:
+ if (value == null) {
+ unsetTableNameOrRegionName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableNameOrRegionName((byte[])value);
+ } else {
+ setTableNameOrRegionName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME_OR_REGION_NAME:
+ return getTableNameOrRegionName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME_OR_REGION_NAME:
+ return isSetTableNameOrRegionName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof majorCompact_args)
+ return this.equals((majorCompact_args)that);
+ return false;
+ }
+
+ public boolean equals(majorCompact_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
+ boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
+ if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
+ if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
+ return false;
+ if (!this.tableNameOrRegionName.equals(that.tableNameOrRegionName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableNameOrRegionName()) ? 131071 : 524287);
+ if (isSetTableNameOrRegionName())
+ hashCode = hashCode * 8191 + tableNameOrRegionName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(majorCompact_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableNameOrRegionName(), other.isSetTableNameOrRegionName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableNameOrRegionName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableNameOrRegionName, other.tableNameOrRegionName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("majorCompact_args(");
+ boolean first = true;
+
+ sb.append("tableNameOrRegionName:");
+ if (this.tableNameOrRegionName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableNameOrRegionName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class majorCompact_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public majorCompact_argsStandardScheme getScheme() {
+ return new majorCompact_argsStandardScheme();
+ }
+ }
+
+ private static class majorCompact_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<majorCompact_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, majorCompact_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME_OR_REGION_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableNameOrRegionName = iprot.readBinary();
+ struct.setTableNameOrRegionNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, majorCompact_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableNameOrRegionName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableNameOrRegionName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class majorCompact_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public majorCompact_argsTupleScheme getScheme() {
+ return new majorCompact_argsTupleScheme();
+ }
+ }
+
+ private static class majorCompact_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<majorCompact_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, majorCompact_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableNameOrRegionName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableNameOrRegionName()) {
+ oprot.writeBinary(struct.tableNameOrRegionName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, majorCompact_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableNameOrRegionName = iprot.readBinary();
+ struct.setTableNameOrRegionNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class majorCompact_result implements org.apache.thrift.TBase<majorCompact_result, majorCompact_result._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new majorCompact_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new majorCompact_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(majorCompact_result.class, metaDataMap);
+ }
+
+ public majorCompact_result() {
+ }
+
+ public majorCompact_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public majorCompact_result(majorCompact_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public majorCompact_result deepCopy() {
+ return new majorCompact_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public majorCompact_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof majorCompact_result)
+ return this.equals((majorCompact_result)that);
+ return false;
+ }
+
+ public boolean equals(majorCompact_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(majorCompact_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("majorCompact_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class majorCompact_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public majorCompact_resultStandardScheme getScheme() {
+ return new majorCompact_resultStandardScheme();
+ }
+ }
+
+ private static class majorCompact_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<majorCompact_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, majorCompact_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, majorCompact_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class majorCompact_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public majorCompact_resultTupleScheme getScheme() {
+ return new majorCompact_resultTupleScheme();
+ }
+ }
+
+ private static class majorCompact_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<majorCompact_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, majorCompact_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, majorCompact_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNames_args implements org.apache.thrift.TBase<getTableNames_args, getTableNames_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNames_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNames_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNames_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNames_args.class, metaDataMap);
+ }
+
+ public getTableNames_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNames_args(getTableNames_args other) {
+ }
+
+ public getTableNames_args deepCopy() {
+ return new getTableNames_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNames_args)
+ return this.equals((getTableNames_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableNames_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNames_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNames_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNames_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNames_argsStandardScheme getScheme() {
+ return new getTableNames_argsStandardScheme();
+ }
+ }
+
+ private static class getTableNames_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNames_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNames_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNames_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNames_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNames_argsTupleScheme getScheme() {
+ return new getTableNames_argsTupleScheme();
+ }
+ }
+
+ private static class getTableNames_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNames_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNames_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNames_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNames_result implements org.apache.thrift.TBase<getTableNames_result, getTableNames_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNames_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNames_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNames_result.class, metaDataMap);
+ }
+
+ public getTableNames_result() {
+ }
+
+ public getTableNames_result(
+ java.util.List<java.nio.ByteBuffer> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNames_result(getTableNames_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<java.nio.ByteBuffer> __this__success = new java.util.ArrayList<java.nio.ByteBuffer>(other.success.size());
+ for (java.nio.ByteBuffer other_element : other.success) {
+ __this__success.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getTableNames_result deepCopy() {
+ return new getTableNames_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(java.nio.ByteBuffer elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getSuccess() {
+ return this.success;
+ }
+
+ public getTableNames_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getTableNames_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNames_result)
+ return this.equals((getTableNames_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableNames_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNames_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNames_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.success, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNames_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNames_resultStandardScheme getScheme() {
+ return new getTableNames_resultStandardScheme();
+ }
+ }
+
+ private static class getTableNames_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNames_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNames_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list50 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<java.nio.ByteBuffer>(_list50.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem51;
+ for (int _i52 = 0; _i52 < _list50.size; ++_i52)
+ {
+ _elem51 = iprot.readBinary();
+ struct.success.add(_elem51);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNames_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size()));
+ for (java.nio.ByteBuffer _iter53 : struct.success)
+ {
+ oprot.writeBinary(_iter53);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNames_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNames_resultTupleScheme getScheme() {
+ return new getTableNames_resultTupleScheme();
+ }
+ }
+
+ private static class getTableNames_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNames_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNames_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (java.nio.ByteBuffer _iter54 : struct.success)
+ {
+ oprot.writeBinary(_iter54);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNames_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list55 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.success = new java.util.ArrayList<java.nio.ByteBuffer>(_list55.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem56;
+ for (int _i57 = 0; _i57 < _list55.size; ++_i57)
+ {
+ _elem56 = iprot.readBinary();
+ struct.success.add(_elem56);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNamesWithIsTableEnabled_args implements org.apache.thrift.TBase<getTableNamesWithIsTableEnabled_args, getTableNamesWithIsTableEnabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNamesWithIsTableEnabled_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesWithIsTableEnabled_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesWithIsTableEnabled_args.class, metaDataMap);
+ }
+
+ public getTableNamesWithIsTableEnabled_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNamesWithIsTableEnabled_args(getTableNamesWithIsTableEnabled_args other) {
+ }
+
+ public getTableNamesWithIsTableEnabled_args deepCopy() {
+ return new getTableNamesWithIsTableEnabled_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNamesWithIsTableEnabled_args)
+ return this.equals((getTableNamesWithIsTableEnabled_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableNamesWithIsTableEnabled_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNamesWithIsTableEnabled_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesWithIsTableEnabled_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNamesWithIsTableEnabled_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesWithIsTableEnabled_argsStandardScheme getScheme() {
+ return new getTableNamesWithIsTableEnabled_argsStandardScheme();
+ }
+ }
+
+ private static class getTableNamesWithIsTableEnabled_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNamesWithIsTableEnabled_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesWithIsTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNamesWithIsTableEnabled_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNamesWithIsTableEnabled_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesWithIsTableEnabled_argsTupleScheme getScheme() {
+ return new getTableNamesWithIsTableEnabled_argsTupleScheme();
+ }
+ }
+
+ private static class getTableNamesWithIsTableEnabled_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNamesWithIsTableEnabled_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNamesWithIsTableEnabled_result implements org.apache.thrift.TBase<getTableNamesWithIsTableEnabled_result, getTableNamesWithIsTableEnabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNamesWithIsTableEnabled_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesWithIsTableEnabled_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.MAP, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesWithIsTableEnabled_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesWithIsTableEnabled_result.class, metaDataMap);
+ }
+
+ public getTableNamesWithIsTableEnabled_result() {
+ }
+
+ public getTableNamesWithIsTableEnabled_result(
+ java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNamesWithIsTableEnabled_result(getTableNamesWithIsTableEnabled_result other) {
+ if (other.isSetSuccess()) {
+ java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> __this__success = new java.util.HashMap<java.nio.ByteBuffer,java.lang.Boolean>(other.success.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.lang.Boolean> other_element : other.success.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.lang.Boolean other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__success_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.lang.Boolean __this__success_copy_value = other_element_value;
+
+ __this__success.put(__this__success_copy_key, __this__success_copy_value);
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getTableNamesWithIsTableEnabled_result deepCopy() {
+ return new getTableNamesWithIsTableEnabled_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ public void putToSuccess(java.nio.ByteBuffer key, boolean val) {
+ if (this.success == null) {
+ this.success = new java.util.HashMap<java.nio.ByteBuffer,java.lang.Boolean>();
+ }
+ this.success.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> getSuccess() {
+ return this.success;
+ }
+
+ public getTableNamesWithIsTableEnabled_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.lang.Boolean> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getTableNamesWithIsTableEnabled_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.Map<java.nio.ByteBuffer,java.lang.Boolean>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNamesWithIsTableEnabled_result)
+ return this.equals((getTableNamesWithIsTableEnabled_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableNamesWithIsTableEnabled_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNamesWithIsTableEnabled_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesWithIsTableEnabled_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNamesWithIsTableEnabled_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesWithIsTableEnabled_resultStandardScheme getScheme() {
+ return new getTableNamesWithIsTableEnabled_resultStandardScheme();
+ }
+ }
+
+ private static class getTableNamesWithIsTableEnabled_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNamesWithIsTableEnabled_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesWithIsTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map58 = iprot.readMapBegin();
+ struct.success = new java.util.HashMap<java.nio.ByteBuffer,java.lang.Boolean>(2*_map58.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key59;
+ boolean _val60;
+ for (int _i61 = 0; _i61 < _map58.size; ++_i61)
+ {
+ _key59 = iprot.readBinary();
+ _val60 = iprot.readBool();
+ struct.success.put(_key59, _val60);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNamesWithIsTableEnabled_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.BOOL, struct.success.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.lang.Boolean> _iter62 : struct.success.entrySet())
+ {
+ oprot.writeBinary(_iter62.getKey());
+ oprot.writeBool(_iter62.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNamesWithIsTableEnabled_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesWithIsTableEnabled_resultTupleScheme getScheme() {
+ return new getTableNamesWithIsTableEnabled_resultTupleScheme();
+ }
+ }
+
+ private static class getTableNamesWithIsTableEnabled_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNamesWithIsTableEnabled_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.lang.Boolean> _iter63 : struct.success.entrySet())
+ {
+ oprot.writeBinary(_iter63.getKey());
+ oprot.writeBool(_iter63.getValue());
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesWithIsTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TMap _map64 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.BOOL);
+ struct.success = new java.util.HashMap<java.nio.ByteBuffer,java.lang.Boolean>(2*_map64.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key65;
+ boolean _val66;
+ for (int _i67 = 0; _i67 < _map64.size; ++_i67)
+ {
+ _key65 = iprot.readBinary();
+ _val66 = iprot.readBool();
+ struct.success.put(_key65, _val66);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getColumnDescriptors_args implements org.apache.thrift.TBase<getColumnDescriptors_args, getColumnDescriptors_args._Fields>, java.io.Serializable, Cloneable, Comparable<getColumnDescriptors_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getColumnDescriptors_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getColumnDescriptors_argsTupleSchemeFactory();
+
+ /**
+ * table name
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * table name
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getColumnDescriptors_args.class, metaDataMap);
+ }
+
+ public getColumnDescriptors_args() {
+ }
+
+ public getColumnDescriptors_args(
+ java.nio.ByteBuffer tableName)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getColumnDescriptors_args(getColumnDescriptors_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ }
+
+ public getColumnDescriptors_args deepCopy() {
+ return new getColumnDescriptors_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * table name
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * table name
+ */
+ public getColumnDescriptors_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getColumnDescriptors_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getColumnDescriptors_args)
+ return this.equals((getColumnDescriptors_args)that);
+ return false;
+ }
+
+ public boolean equals(getColumnDescriptors_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getColumnDescriptors_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getColumnDescriptors_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getColumnDescriptors_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getColumnDescriptors_argsStandardScheme getScheme() {
+ return new getColumnDescriptors_argsStandardScheme();
+ }
+ }
+
+ private static class getColumnDescriptors_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getColumnDescriptors_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getColumnDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getColumnDescriptors_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getColumnDescriptors_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getColumnDescriptors_argsTupleScheme getScheme() {
+ return new getColumnDescriptors_argsTupleScheme();
+ }
+ }
+
+ private static class getColumnDescriptors_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getColumnDescriptors_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getColumnDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getColumnDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getColumnDescriptors_result implements org.apache.thrift.TBase<getColumnDescriptors_result, getColumnDescriptors_result._Fields>, java.io.Serializable, Cloneable, Comparable<getColumnDescriptors_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getColumnDescriptors_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getColumnDescriptors_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getColumnDescriptors_result.class, metaDataMap);
+ }
+
+ public getColumnDescriptors_result() {
+ }
+
+ public getColumnDescriptors_result(
+ java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getColumnDescriptors_result(getColumnDescriptors_result other) {
+ if (other.isSetSuccess()) {
+ java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> __this__success = new java.util.HashMap<java.nio.ByteBuffer,ColumnDescriptor>(other.success.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, ColumnDescriptor> other_element : other.success.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ ColumnDescriptor other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__success_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ ColumnDescriptor __this__success_copy_value = new ColumnDescriptor(other_element_value);
+
+ __this__success.put(__this__success_copy_key, __this__success_copy_value);
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getColumnDescriptors_result deepCopy() {
+ return new getColumnDescriptors_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ public void putToSuccess(java.nio.ByteBuffer key, ColumnDescriptor val) {
+ if (this.success == null) {
+ this.success = new java.util.HashMap<java.nio.ByteBuffer,ColumnDescriptor>();
+ }
+ this.success.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> getSuccess() {
+ return this.success;
+ }
+
+ public getColumnDescriptors_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,ColumnDescriptor> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getColumnDescriptors_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.Map<java.nio.ByteBuffer,ColumnDescriptor>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getColumnDescriptors_result)
+ return this.equals((getColumnDescriptors_result)that);
+ return false;
+ }
+
+ public boolean equals(getColumnDescriptors_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getColumnDescriptors_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getColumnDescriptors_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getColumnDescriptors_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getColumnDescriptors_resultStandardScheme getScheme() {
+ return new getColumnDescriptors_resultStandardScheme();
+ }
+ }
+
+ private static class getColumnDescriptors_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getColumnDescriptors_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getColumnDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map68 = iprot.readMapBegin();
+ struct.success = new java.util.HashMap<java.nio.ByteBuffer,ColumnDescriptor>(2*_map68.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key69;
+ @org.apache.thrift.annotation.Nullable ColumnDescriptor _val70;
+ for (int _i71 = 0; _i71 < _map68.size; ++_i71)
+ {
+ _key69 = iprot.readBinary();
+ _val70 = new ColumnDescriptor();
+ _val70.read(iprot);
+ struct.success.put(_key69, _val70);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getColumnDescriptors_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, ColumnDescriptor> _iter72 : struct.success.entrySet())
+ {
+ oprot.writeBinary(_iter72.getKey());
+ _iter72.getValue().write(oprot);
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getColumnDescriptors_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getColumnDescriptors_resultTupleScheme getScheme() {
+ return new getColumnDescriptors_resultTupleScheme();
+ }
+ }
+
+ private static class getColumnDescriptors_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getColumnDescriptors_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getColumnDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, ColumnDescriptor> _iter73 : struct.success.entrySet())
+ {
+ oprot.writeBinary(_iter73.getKey());
+ _iter73.getValue().write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getColumnDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TMap _map74 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.HashMap<java.nio.ByteBuffer,ColumnDescriptor>(2*_map74.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key75;
+ @org.apache.thrift.annotation.Nullable ColumnDescriptor _val76;
+ for (int _i77 = 0; _i77 < _map74.size; ++_i77)
+ {
+ _key75 = iprot.readBinary();
+ _val76 = new ColumnDescriptor();
+ _val76.read(iprot);
+ struct.success.put(_key75, _val76);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableRegions_args implements org.apache.thrift.TBase<getTableRegions_args, getTableRegions_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableRegions_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableRegions_argsTupleSchemeFactory();
+
+ /**
+ * table name
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * table name
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableRegions_args.class, metaDataMap);
+ }
+
+ public getTableRegions_args() {
+ }
+
+ public getTableRegions_args(
+ java.nio.ByteBuffer tableName)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableRegions_args(getTableRegions_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ }
+
+ public getTableRegions_args deepCopy() {
+ return new getTableRegions_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * table name
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * table name
+ */
+ public getTableRegions_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getTableRegions_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableRegions_args)
+ return this.equals((getTableRegions_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableRegions_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableRegions_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableRegions_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableRegions_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableRegions_argsStandardScheme getScheme() {
+ return new getTableRegions_argsStandardScheme();
+ }
+ }
+
+ private static class getTableRegions_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableRegions_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableRegions_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableRegions_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableRegions_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableRegions_argsTupleScheme getScheme() {
+ return new getTableRegions_argsTupleScheme();
+ }
+ }
+
+ private static class getTableRegions_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableRegions_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableRegions_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableRegions_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableRegions_result implements org.apache.thrift.TBase<getTableRegions_result, getTableRegions_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableRegions_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableRegions_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRegionInfo> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableRegions_result.class, metaDataMap);
+ }
+
+ public getTableRegions_result() {
+ }
+
+ public getTableRegions_result(
+ java.util.List<TRegionInfo> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableRegions_result(getTableRegions_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRegionInfo> __this__success = new java.util.ArrayList<TRegionInfo>(other.success.size());
+ for (TRegionInfo other_element : other.success) {
+ __this__success.add(new TRegionInfo(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getTableRegions_result deepCopy() {
+ return new getTableRegions_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRegionInfo> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRegionInfo elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRegionInfo>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRegionInfo> getSuccess() {
+ return this.success;
+ }
+
+ public getTableRegions_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRegionInfo> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getTableRegions_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRegionInfo>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableRegions_result)
+ return this.equals((getTableRegions_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableRegions_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableRegions_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableRegions_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableRegions_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableRegions_resultStandardScheme getScheme() {
+ return new getTableRegions_resultStandardScheme();
+ }
+ }
+
+ private static class getTableRegions_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableRegions_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableRegions_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list78 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRegionInfo>(_list78.size);
+ @org.apache.thrift.annotation.Nullable TRegionInfo _elem79;
+ for (int _i80 = 0; _i80 < _list78.size; ++_i80)
+ {
+ _elem79 = new TRegionInfo();
+ _elem79.read(iprot);
+ struct.success.add(_elem79);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableRegions_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRegionInfo _iter81 : struct.success)
+ {
+ _iter81.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableRegions_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableRegions_resultTupleScheme getScheme() {
+ return new getTableRegions_resultTupleScheme();
+ }
+ }
+
+ private static class getTableRegions_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableRegions_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableRegions_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRegionInfo _iter82 : struct.success)
+ {
+ _iter82.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableRegions_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list83 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRegionInfo>(_list83.size);
+ @org.apache.thrift.annotation.Nullable TRegionInfo _elem84;
+ for (int _i85 = 0; _i85 < _list83.size; ++_i85)
+ {
+ _elem84 = new TRegionInfo();
+ _elem84.read(iprot);
+ struct.success.add(_elem84);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class createTable_args implements org.apache.thrift.TBase<createTable_args, createTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new createTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new createTable_argsTupleSchemeFactory();
+
+ /**
+ * name of table to create
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * list of column family descriptors
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<ColumnDescriptor> columnFamilies; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table to create
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * list of column family descriptors
+ */
+ COLUMN_FAMILIES((short)2, "columnFamilies");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // COLUMN_FAMILIES
+ return COLUMN_FAMILIES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap);
+ }
+
+ public createTable_args() {
+ }
+
+ public createTable_args(
+ java.nio.ByteBuffer tableName,
+ java.util.List<ColumnDescriptor> columnFamilies)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.columnFamilies = columnFamilies;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public createTable_args(createTable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetColumnFamilies()) {
+ java.util.List<ColumnDescriptor> __this__columnFamilies = new java.util.ArrayList<ColumnDescriptor>(other.columnFamilies.size());
+ for (ColumnDescriptor other_element : other.columnFamilies) {
+ __this__columnFamilies.add(new ColumnDescriptor(other_element));
+ }
+ this.columnFamilies = __this__columnFamilies;
+ }
+ }
+
+ public createTable_args deepCopy() {
+ return new createTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.columnFamilies = null;
+ }
+
+ /**
+ * name of table to create
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table to create
+ */
+ public createTable_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public createTable_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getColumnFamiliesSize() {
+ return (this.columnFamilies == null) ? 0 : this.columnFamilies.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<ColumnDescriptor> getColumnFamiliesIterator() {
+ return (this.columnFamilies == null) ? null : this.columnFamilies.iterator();
+ }
+
+ public void addToColumnFamilies(ColumnDescriptor elem) {
+ if (this.columnFamilies == null) {
+ this.columnFamilies = new java.util.ArrayList<ColumnDescriptor>();
+ }
+ this.columnFamilies.add(elem);
+ }
+
+ /**
+ * list of column family descriptors
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<ColumnDescriptor> getColumnFamilies() {
+ return this.columnFamilies;
+ }
+
+ /**
+ * list of column family descriptors
+ */
+ public createTable_args setColumnFamilies(@org.apache.thrift.annotation.Nullable java.util.List<ColumnDescriptor> columnFamilies) {
+ this.columnFamilies = columnFamilies;
+ return this;
+ }
+
+ public void unsetColumnFamilies() {
+ this.columnFamilies = null;
+ }
+
+ /** Returns true if field columnFamilies is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumnFamilies() {
+ return this.columnFamilies != null;
+ }
+
+ public void setColumnFamiliesIsSet(boolean value) {
+ if (!value) {
+ this.columnFamilies = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN_FAMILIES:
+ if (value == null) {
+ unsetColumnFamilies();
+ } else {
+ setColumnFamilies((java.util.List<ColumnDescriptor>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case COLUMN_FAMILIES:
+ return getColumnFamilies();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case COLUMN_FAMILIES:
+ return isSetColumnFamilies();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof createTable_args)
+ return this.equals((createTable_args)that);
+ return false;
+ }
+
+ public boolean equals(createTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_columnFamilies = true && this.isSetColumnFamilies();
+ boolean that_present_columnFamilies = true && that.isSetColumnFamilies();
+ if (this_present_columnFamilies || that_present_columnFamilies) {
+ if (!(this_present_columnFamilies && that_present_columnFamilies))
+ return false;
+ if (!this.columnFamilies.equals(that.columnFamilies))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumnFamilies()) ? 131071 : 524287);
+ if (isSetColumnFamilies())
+ hashCode = hashCode * 8191 + columnFamilies.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(createTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumnFamilies(), other.isSetColumnFamilies());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumnFamilies()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columnFamilies, other.columnFamilies);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("createTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columnFamilies:");
+ if (this.columnFamilies == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columnFamilies);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class createTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_argsStandardScheme getScheme() {
+ return new createTable_argsStandardScheme();
+ }
+ }
+
+ private static class createTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<createTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, createTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMN_FAMILIES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list86 = iprot.readListBegin();
+ struct.columnFamilies = new java.util.ArrayList<ColumnDescriptor>(_list86.size);
+ @org.apache.thrift.annotation.Nullable ColumnDescriptor _elem87;
+ for (int _i88 = 0; _i88 < _list86.size; ++_i88)
+ {
+ _elem87 = new ColumnDescriptor();
+ _elem87.read(iprot);
+ struct.columnFamilies.add(_elem87);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnFamiliesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, createTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columnFamilies != null) {
+ oprot.writeFieldBegin(COLUMN_FAMILIES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columnFamilies.size()));
+ for (ColumnDescriptor _iter89 : struct.columnFamilies)
+ {
+ _iter89.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class createTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_argsTupleScheme getScheme() {
+ return new createTable_argsTupleScheme();
+ }
+ }
+
+ private static class createTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<createTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, createTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetColumnFamilies()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetColumnFamilies()) {
+ {
+ oprot.writeI32(struct.columnFamilies.size());
+ for (ColumnDescriptor _iter90 : struct.columnFamilies)
+ {
+ _iter90.write(oprot);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, createTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list91 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columnFamilies = new java.util.ArrayList<ColumnDescriptor>(_list91.size);
+ @org.apache.thrift.annotation.Nullable ColumnDescriptor _elem92;
+ for (int _i93 = 0; _i93 < _list91.size; ++_i93)
+ {
+ _elem92 = new ColumnDescriptor();
+ _elem92.read(iprot);
+ struct.columnFamilies.add(_elem92);
+ }
+ }
+ struct.setColumnFamiliesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class createTable_result implements org.apache.thrift.TBase<createTable_result, createTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new createTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new createTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+ public @org.apache.thrift.annotation.Nullable AlreadyExists exist; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io"),
+ IA((short)2, "ia"),
+ EXIST((short)3, "exist");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ case 3: // EXIST
+ return EXIST;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ tmpMap.put(_Fields.EXIST, new org.apache.thrift.meta_data.FieldMetaData("exist", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, AlreadyExists.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap);
+ }
+
+ public createTable_result() {
+ }
+
+ public createTable_result(
+ IOError io,
+ IllegalArgument ia,
+ AlreadyExists exist)
+ {
+ this();
+ this.io = io;
+ this.ia = ia;
+ this.exist = exist;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public createTable_result(createTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ if (other.isSetExist()) {
+ this.exist = new AlreadyExists(other.exist);
+ }
+ }
+
+ public createTable_result deepCopy() {
+ return new createTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ this.ia = null;
+ this.exist = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public createTable_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public createTable_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public AlreadyExists getExist() {
+ return this.exist;
+ }
+
+ public createTable_result setExist(@org.apache.thrift.annotation.Nullable AlreadyExists exist) {
+ this.exist = exist;
+ return this;
+ }
+
+ public void unsetExist() {
+ this.exist = null;
+ }
+
+ /** Returns true if field exist is set (has been assigned a value) and false otherwise */
+ public boolean isSetExist() {
+ return this.exist != null;
+ }
+
+ public void setExistIsSet(boolean value) {
+ if (!value) {
+ this.exist = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ case EXIST:
+ if (value == null) {
+ unsetExist();
+ } else {
+ setExist((AlreadyExists)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ case EXIST:
+ return getExist();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ case EXIST:
+ return isSetExist();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof createTable_result)
+ return this.equals((createTable_result)that);
+ return false;
+ }
+
+ public boolean equals(createTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ boolean this_present_exist = true && this.isSetExist();
+ boolean that_present_exist = true && that.isSetExist();
+ if (this_present_exist || that_present_exist) {
+ if (!(this_present_exist && that_present_exist))
+ return false;
+ if (!this.exist.equals(that.exist))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetExist()) ? 131071 : 524287);
+ if (isSetExist())
+ hashCode = hashCode * 8191 + exist.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(createTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetExist(), other.isSetExist());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetExist()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.exist, other.exist);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("createTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("exist:");
+ if (this.exist == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.exist);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class createTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_resultStandardScheme getScheme() {
+ return new createTable_resultStandardScheme();
+ }
+ }
+
+ private static class createTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<createTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, createTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // EXIST
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.exist = new AlreadyExists();
+ struct.exist.read(iprot);
+ struct.setExistIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, createTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.exist != null) {
+ oprot.writeFieldBegin(EXIST_FIELD_DESC);
+ struct.exist.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class createTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_resultTupleScheme getScheme() {
+ return new createTable_resultTupleScheme();
+ }
+ }
+
+ private static class createTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<createTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, createTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(1);
+ }
+ if (struct.isSetExist()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ if (struct.isSetExist()) {
+ struct.exist.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, createTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.exist = new AlreadyExists();
+ struct.exist.read(iprot);
+ struct.setExistIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteTable_args implements org.apache.thrift.TBase<deleteTable_args, deleteTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteTable_argsTupleSchemeFactory();
+
+ /**
+ * name of table to delete
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table to delete
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap);
+ }
+
+ public deleteTable_args() {
+ }
+
+ public deleteTable_args(
+ java.nio.ByteBuffer tableName)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteTable_args(deleteTable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ }
+
+ public deleteTable_args deepCopy() {
+ return new deleteTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * name of table to delete
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table to delete
+ */
+ public deleteTable_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public deleteTable_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteTable_args)
+ return this.equals((deleteTable_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_argsStandardScheme getScheme() {
+ return new deleteTable_argsStandardScheme();
+ }
+ }
+
+ private static class deleteTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_argsTupleScheme getScheme() {
+ return new deleteTable_argsTupleScheme();
+ }
+ }
+
+ private static class deleteTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteTable_result implements org.apache.thrift.TBase<deleteTable_result, deleteTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap);
+ }
+
+ public deleteTable_result() {
+ }
+
+ public deleteTable_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteTable_result(deleteTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public deleteTable_result deepCopy() {
+ return new deleteTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public deleteTable_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteTable_result)
+ return this.equals((deleteTable_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_resultStandardScheme getScheme() {
+ return new deleteTable_resultStandardScheme();
+ }
+ }
+
+ private static class deleteTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_resultTupleScheme getScheme() {
+ return new deleteTable_resultTupleScheme();
+ }
+ }
+
+ private static class deleteTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable, Comparable<get_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new get_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new get_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * column name
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * column name
+ */
+ COLUMN((short)3, "column"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
+ }
+
+ public get_args() {
+ }
+
+ public get_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public get_args(get_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public get_args deepCopy() {
+ return new get_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.column = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public get_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public get_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public get_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public get_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * column name
+ */
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * column name
+ */
+ public get_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public get_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public get_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof get_args)
+ return this.equals((get_args)that);
+ return false;
+ }
+
+ public boolean equals(get_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(get_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("get_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class get_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_argsStandardScheme getScheme() {
+ return new get_argsStandardScheme();
+ }
+ }
+
+ private static class get_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<get_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map94 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map94.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key95;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val96;
+ for (int _i97 = 0; _i97 < _map94.size; ++_i97)
+ {
+ _key95 = iprot.readBinary();
+ _val96 = iprot.readBinary();
+ struct.attributes.put(_key95, _val96);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter98 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter98.getKey());
+ oprot.writeBinary(_iter98.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class get_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_argsTupleScheme getScheme() {
+ return new get_argsTupleScheme();
+ }
+ }
+
+ private static class get_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<get_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter99 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter99.getKey());
+ oprot.writeBinary(_iter99.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map100 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map100.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key101;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val102;
+ for (int _i103 = 0; _i103 < _map100.size; ++_i103)
+ {
+ _key101 = iprot.readBinary();
+ _val102 = iprot.readBinary();
+ struct.attributes.put(_key101, _val102);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable, Comparable<get_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new get_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new get_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TCell> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
+ }
+
+ public get_result() {
+ }
+
+ public get_result(
+ java.util.List<TCell> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public get_result(get_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TCell> __this__success = new java.util.ArrayList<TCell>(other.success.size());
+ for (TCell other_element : other.success) {
+ __this__success.add(new TCell(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public get_result deepCopy() {
+ return new get_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TCell> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TCell elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TCell>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TCell> getSuccess() {
+ return this.success;
+ }
+
+ public get_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TCell> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public get_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TCell>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof get_result)
+ return this.equals((get_result)that);
+ return false;
+ }
+
+ public boolean equals(get_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(get_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("get_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class get_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_resultStandardScheme getScheme() {
+ return new get_resultStandardScheme();
+ }
+ }
+
+ private static class get_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<get_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TCell>(_list104.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem105;
+ for (int _i106 = 0; _i106 < _list104.size; ++_i106)
+ {
+ _elem105 = new TCell();
+ _elem105.read(iprot);
+ struct.success.add(_elem105);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TCell _iter107 : struct.success)
+ {
+ _iter107.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class get_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_resultTupleScheme getScheme() {
+ return new get_resultTupleScheme();
+ }
+ }
+
+ private static class get_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<get_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TCell _iter108 : struct.success)
+ {
+ _iter108.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list109 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TCell>(_list109.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem110;
+ for (int _i111 = 0; _i111 < _list109.size; ++_i111)
+ {
+ _elem110 = new TCell();
+ _elem110.read(iprot);
+ struct.success.add(_elem110);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getVer_args implements org.apache.thrift.TBase<getVer_args, getVer_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getVer_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getVer_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * column name
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ /**
+ * number of versions to retrieve
+ */
+ public int numVersions; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * column name
+ */
+ COLUMN((short)3, "column"),
+ /**
+ * number of versions to retrieve
+ */
+ NUM_VERSIONS((short)4, "numVersions"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)5, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // NUM_VERSIONS
+ return NUM_VERSIONS;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __NUMVERSIONS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap);
+ }
+
+ public getVer_args() {
+ }
+
+ public getVer_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ int numVersions,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.numVersions = numVersions;
+ setNumVersionsIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getVer_args(getVer_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ this.numVersions = other.numVersions;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getVer_args deepCopy() {
+ return new getVer_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.column = null;
+ setNumVersionsIsSet(false);
+ this.numVersions = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getVer_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getVer_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public getVer_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getVer_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * column name
+ */
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * column name
+ */
+ public getVer_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public getVer_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ /**
+ * number of versions to retrieve
+ */
+ public int getNumVersions() {
+ return this.numVersions;
+ }
+
+ /**
+ * number of versions to retrieve
+ */
+ public getVer_args setNumVersions(int numVersions) {
+ this.numVersions = numVersions;
+ setNumVersionsIsSet(true);
+ return this;
+ }
+
+ public void unsetNumVersions() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __NUMVERSIONS_ISSET_ID);
+ }
+
+ /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumVersions() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __NUMVERSIONS_ISSET_ID);
+ }
+
+ public void setNumVersionsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __NUMVERSIONS_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getVer_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case NUM_VERSIONS:
+ if (value == null) {
+ unsetNumVersions();
+ } else {
+ setNumVersions((java.lang.Integer)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case NUM_VERSIONS:
+ return getNumVersions();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case NUM_VERSIONS:
+ return isSetNumVersions();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getVer_args)
+ return this.equals((getVer_args)that);
+ return false;
+ }
+
+ public boolean equals(getVer_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_numVersions = true;
+ boolean that_present_numVersions = true;
+ if (this_present_numVersions || that_present_numVersions) {
+ if (!(this_present_numVersions && that_present_numVersions))
+ return false;
+ if (this.numVersions != that.numVersions)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + numVersions;
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getVer_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetNumVersions(), other.isSetNumVersions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNumVersions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, other.numVersions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getVer_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("numVersions:");
+ sb.append(this.numVersions);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getVer_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVer_argsStandardScheme getScheme() {
+ return new getVer_argsStandardScheme();
+ }
+ }
+
+ private static class getVer_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getVer_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getVer_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // NUM_VERSIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.numVersions = iprot.readI32();
+ struct.setNumVersionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map112 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map112.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key113;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val114;
+ for (int _i115 = 0; _i115 < _map112.size; ++_i115)
+ {
+ _key113 = iprot.readBinary();
+ _val114 = iprot.readBinary();
+ struct.attributes.put(_key113, _val114);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getVer_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
+ oprot.writeI32(struct.numVersions);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter116 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter116.getKey());
+ oprot.writeBinary(_iter116.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getVer_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVer_argsTupleScheme getScheme() {
+ return new getVer_argsTupleScheme();
+ }
+ }
+
+ private static class getVer_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getVer_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getVer_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetNumVersions()) {
+ optionals.set(3);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetNumVersions()) {
+ oprot.writeI32(struct.numVersions);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter117 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter117.getKey());
+ oprot.writeBinary(_iter117.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getVer_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.numVersions = iprot.readI32();
+ struct.setNumVersionsIsSet(true);
+ }
+ if (incoming.get(4)) {
+ {
+ org.apache.thrift.protocol.TMap _map118 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map118.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key119;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val120;
+ for (int _i121 = 0; _i121 < _map118.size; ++_i121)
+ {
+ _key119 = iprot.readBinary();
+ _val120 = iprot.readBinary();
+ struct.attributes.put(_key119, _val120);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getVer_result implements org.apache.thrift.TBase<getVer_result, getVer_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getVer_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getVer_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TCell> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap);
+ }
+
+ public getVer_result() {
+ }
+
+ public getVer_result(
+ java.util.List<TCell> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getVer_result(getVer_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TCell> __this__success = new java.util.ArrayList<TCell>(other.success.size());
+ for (TCell other_element : other.success) {
+ __this__success.add(new TCell(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getVer_result deepCopy() {
+ return new getVer_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TCell> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TCell elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TCell>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TCell> getSuccess() {
+ return this.success;
+ }
+
+ public getVer_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TCell> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getVer_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TCell>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getVer_result)
+ return this.equals((getVer_result)that);
+ return false;
+ }
+
+ public boolean equals(getVer_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getVer_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getVer_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getVer_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVer_resultStandardScheme getScheme() {
+ return new getVer_resultStandardScheme();
+ }
+ }
+
+ private static class getVer_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getVer_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getVer_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list122 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TCell>(_list122.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem123;
+ for (int _i124 = 0; _i124 < _list122.size; ++_i124)
+ {
+ _elem123 = new TCell();
+ _elem123.read(iprot);
+ struct.success.add(_elem123);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getVer_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TCell _iter125 : struct.success)
+ {
+ _iter125.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getVer_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVer_resultTupleScheme getScheme() {
+ return new getVer_resultTupleScheme();
+ }
+ }
+
+ private static class getVer_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getVer_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getVer_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TCell _iter126 : struct.success)
+ {
+ _iter126.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getVer_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list127 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TCell>(_list127.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem128;
+ for (int _i129 = 0; _i129 < _list127.size; ++_i129)
+ {
+ _elem128 = new TCell();
+ _elem128.read(iprot);
+ struct.success.add(_elem128);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getVerTs_args implements org.apache.thrift.TBase<getVerTs_args, getVerTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getVerTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getVerTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * column name
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * number of versions to retrieve
+ */
+ public int numVersions; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * column name
+ */
+ COLUMN((short)3, "column"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)4, "timestamp"),
+ /**
+ * number of versions to retrieve
+ */
+ NUM_VERSIONS((short)5, "numVersions"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)6, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // NUM_VERSIONS
+ return NUM_VERSIONS;
+ case 6: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private static final int __NUMVERSIONS_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap);
+ }
+
+ public getVerTs_args() {
+ }
+
+ public getVerTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ long timestamp,
+ int numVersions,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.numVersions = numVersions;
+ setNumVersionsIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getVerTs_args(getVerTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ this.timestamp = other.timestamp;
+ this.numVersions = other.numVersions;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getVerTs_args deepCopy() {
+ return new getVerTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.column = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ setNumVersionsIsSet(false);
+ this.numVersions = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getVerTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getVerTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public getVerTs_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getVerTs_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * column name
+ */
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * column name
+ */
+ public getVerTs_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public getVerTs_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public getVerTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ /**
+ * number of versions to retrieve
+ */
+ public int getNumVersions() {
+ return this.numVersions;
+ }
+
+ /**
+ * number of versions to retrieve
+ */
+ public getVerTs_args setNumVersions(int numVersions) {
+ this.numVersions = numVersions;
+ setNumVersionsIsSet(true);
+ return this;
+ }
+
+ public void unsetNumVersions() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __NUMVERSIONS_ISSET_ID);
+ }
+
+ /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumVersions() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __NUMVERSIONS_ISSET_ID);
+ }
+
+ public void setNumVersionsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __NUMVERSIONS_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getVerTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case NUM_VERSIONS:
+ if (value == null) {
+ unsetNumVersions();
+ } else {
+ setNumVersions((java.lang.Integer)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case NUM_VERSIONS:
+ return getNumVersions();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case NUM_VERSIONS:
+ return isSetNumVersions();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getVerTs_args)
+ return this.equals((getVerTs_args)that);
+ return false;
+ }
+
+ public boolean equals(getVerTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_numVersions = true;
+ boolean that_present_numVersions = true;
+ if (this_present_numVersions || that_present_numVersions) {
+ if (!(this_present_numVersions && that_present_numVersions))
+ return false;
+ if (this.numVersions != that.numVersions)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + numVersions;
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getVerTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetNumVersions(), other.isSetNumVersions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNumVersions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, other.numVersions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getVerTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("numVersions:");
+ sb.append(this.numVersions);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getVerTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVerTs_argsStandardScheme getScheme() {
+ return new getVerTs_argsStandardScheme();
+ }
+ }
+
+ private static class getVerTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getVerTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getVerTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // NUM_VERSIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.numVersions = iprot.readI32();
+ struct.setNumVersionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map130 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map130.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key131;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val132;
+ for (int _i133 = 0; _i133 < _map130.size; ++_i133)
+ {
+ _key131 = iprot.readBinary();
+ _val132 = iprot.readBinary();
+ struct.attributes.put(_key131, _val132);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getVerTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
+ oprot.writeI32(struct.numVersions);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter134 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter134.getKey());
+ oprot.writeBinary(_iter134.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getVerTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVerTs_argsTupleScheme getScheme() {
+ return new getVerTs_argsTupleScheme();
+ }
+ }
+
+ private static class getVerTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getVerTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getVerTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(3);
+ }
+ if (struct.isSetNumVersions()) {
+ optionals.set(4);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(5);
+ }
+ oprot.writeBitSet(optionals, 6);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetNumVersions()) {
+ oprot.writeI32(struct.numVersions);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter135 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter135.getKey());
+ oprot.writeBinary(_iter135.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getVerTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(6);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.numVersions = iprot.readI32();
+ struct.setNumVersionsIsSet(true);
+ }
+ if (incoming.get(5)) {
+ {
+ org.apache.thrift.protocol.TMap _map136 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map136.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key137;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val138;
+ for (int _i139 = 0; _i139 < _map136.size; ++_i139)
+ {
+ _key137 = iprot.readBinary();
+ _val138 = iprot.readBinary();
+ struct.attributes.put(_key137, _val138);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getVerTs_result implements org.apache.thrift.TBase<getVerTs_result, getVerTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getVerTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getVerTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TCell> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap);
+ }
+
+ public getVerTs_result() {
+ }
+
+ public getVerTs_result(
+ java.util.List<TCell> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getVerTs_result(getVerTs_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TCell> __this__success = new java.util.ArrayList<TCell>(other.success.size());
+ for (TCell other_element : other.success) {
+ __this__success.add(new TCell(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getVerTs_result deepCopy() {
+ return new getVerTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TCell> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TCell elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TCell>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TCell> getSuccess() {
+ return this.success;
+ }
+
+ public getVerTs_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TCell> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getVerTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TCell>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getVerTs_result)
+ return this.equals((getVerTs_result)that);
+ return false;
+ }
+
+ public boolean equals(getVerTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getVerTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getVerTs_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getVerTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVerTs_resultStandardScheme getScheme() {
+ return new getVerTs_resultStandardScheme();
+ }
+ }
+
+ private static class getVerTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getVerTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getVerTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TCell>(_list140.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem141;
+ for (int _i142 = 0; _i142 < _list140.size; ++_i142)
+ {
+ _elem141 = new TCell();
+ _elem141.read(iprot);
+ struct.success.add(_elem141);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getVerTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TCell _iter143 : struct.success)
+ {
+ _iter143.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getVerTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getVerTs_resultTupleScheme getScheme() {
+ return new getVerTs_resultTupleScheme();
+ }
+ }
+
+ private static class getVerTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getVerTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getVerTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TCell _iter144 : struct.success)
+ {
+ _iter144.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getVerTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list145 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TCell>(_list145.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem146;
+ for (int _i147 = 0; _i147 < _list145.size; ++_i147)
+ {
+ _elem146 = new TCell();
+ _elem146.read(iprot);
+ struct.success.add(_elem146);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRow_args implements org.apache.thrift.TBase<getRow_args, getRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRow_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRow_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRow_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)3, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap);
+ }
+
+ public getRow_args() {
+ }
+
+ public getRow_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRow_args(getRow_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRow_args deepCopy() {
+ return new getRow_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getRow_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRow_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public getRow_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getRow_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRow_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRow_args)
+ return this.equals((getRow_args)that);
+ return false;
+ }
+
+ public boolean equals(getRow_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRow_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRow_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRow_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRow_argsStandardScheme getScheme() {
+ return new getRow_argsStandardScheme();
+ }
+ }
+
+ private static class getRow_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRow_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map148 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map148.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key149;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val150;
+ for (int _i151 = 0; _i151 < _map148.size; ++_i151)
+ {
+ _key149 = iprot.readBinary();
+ _val150 = iprot.readBinary();
+ struct.attributes.put(_key149, _val150);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRow_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter152 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter152.getKey());
+ oprot.writeBinary(_iter152.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRow_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRow_argsTupleScheme getScheme() {
+ return new getRow_argsTupleScheme();
+ }
+ }
+
+ private static class getRow_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRow_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter153 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter153.getKey());
+ oprot.writeBinary(_iter153.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TMap _map154 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map154.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key155;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val156;
+ for (int _i157 = 0; _i157 < _map154.size; ++_i157)
+ {
+ _key155 = iprot.readBinary();
+ _val156 = iprot.readBinary();
+ struct.attributes.put(_key155, _val156);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRow_result implements org.apache.thrift.TBase<getRow_result, getRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRow_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRow_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRow_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap);
+ }
+
+ public getRow_result() {
+ }
+
+ public getRow_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRow_result(getRow_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRow_result deepCopy() {
+ return new getRow_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRow_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRow_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRow_result)
+ return this.equals((getRow_result)that);
+ return false;
+ }
+
+ public boolean equals(getRow_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRow_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRow_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRow_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRow_resultStandardScheme getScheme() {
+ return new getRow_resultStandardScheme();
+ }
+ }
+
+ private static class getRow_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRow_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list158 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list158.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem159;
+ for (int _i160 = 0; _i160 < _list158.size; ++_i160)
+ {
+ _elem159 = new TRowResult();
+ _elem159.read(iprot);
+ struct.success.add(_elem159);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRow_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter161 : struct.success)
+ {
+ _iter161.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRow_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRow_resultTupleScheme getScheme() {
+ return new getRow_resultTupleScheme();
+ }
+ }
+
+ private static class getRow_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRow_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter162 : struct.success)
+ {
+ _iter162.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list163 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list163.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem164;
+ for (int _i165 = 0; _i165 < _list163.size; ++_i165)
+ {
+ _elem164 = new TRowResult();
+ _elem164.read(iprot);
+ struct.success.add(_elem164);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowWithColumns_args implements org.apache.thrift.TBase<getRowWithColumns_args, getRowWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumns_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowWithColumns_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowWithColumns_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * List of columns to return, null for all columns
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * List of columns to return, null for all columns
+ */
+ COLUMNS((short)3, "columns"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap);
+ }
+
+ public getRowWithColumns_args() {
+ }
+
+ public getRowWithColumns_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.util.List<java.nio.ByteBuffer> columns,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowWithColumns_args(getRowWithColumns_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRowWithColumns_args deepCopy() {
+ return new getRowWithColumns_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.columns = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getRowWithColumns_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRowWithColumns_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public getRowWithColumns_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getRowWithColumns_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ public getRowWithColumns_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRowWithColumns_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowWithColumns_args)
+ return this.equals((getRowWithColumns_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowWithColumns_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowWithColumns_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowWithColumns_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowWithColumns_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumns_argsStandardScheme getScheme() {
+ return new getRowWithColumns_argsStandardScheme();
+ }
+ }
+
+ private static class getRowWithColumns_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowWithColumns_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowWithColumns_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list166 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list166.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem167;
+ for (int _i168 = 0; _i168 < _list166.size; ++_i168)
+ {
+ _elem167 = iprot.readBinary();
+ struct.columns.add(_elem167);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map169 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map169.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key170;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val171;
+ for (int _i172 = 0; _i172 < _map169.size; ++_i172)
+ {
+ _key170 = iprot.readBinary();
+ _val171 = iprot.readBinary();
+ struct.attributes.put(_key170, _val171);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowWithColumns_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter173 : struct.columns)
+ {
+ oprot.writeBinary(_iter173);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter174 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter174.getKey());
+ oprot.writeBinary(_iter174.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowWithColumns_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumns_argsTupleScheme getScheme() {
+ return new getRowWithColumns_argsTupleScheme();
+ }
+ }
+
+ private static class getRowWithColumns_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowWithColumns_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowWithColumns_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter175 : struct.columns)
+ {
+ oprot.writeBinary(_iter175);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter176 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter176.getKey());
+ oprot.writeBinary(_iter176.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowWithColumns_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list177 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list177.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem178;
+ for (int _i179 = 0; _i179 < _list177.size; ++_i179)
+ {
+ _elem178 = iprot.readBinary();
+ struct.columns.add(_elem178);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map180 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map180.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key181;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val182;
+ for (int _i183 = 0; _i183 < _map180.size; ++_i183)
+ {
+ _key181 = iprot.readBinary();
+ _val182 = iprot.readBinary();
+ struct.attributes.put(_key181, _val182);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowWithColumns_result implements org.apache.thrift.TBase<getRowWithColumns_result, getRowWithColumns_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumns_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowWithColumns_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowWithColumns_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap);
+ }
+
+ public getRowWithColumns_result() {
+ }
+
+ public getRowWithColumns_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowWithColumns_result(getRowWithColumns_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRowWithColumns_result deepCopy() {
+ return new getRowWithColumns_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRowWithColumns_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRowWithColumns_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowWithColumns_result)
+ return this.equals((getRowWithColumns_result)that);
+ return false;
+ }
+
+ public boolean equals(getRowWithColumns_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowWithColumns_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowWithColumns_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowWithColumns_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumns_resultStandardScheme getScheme() {
+ return new getRowWithColumns_resultStandardScheme();
+ }
+ }
+
+ private static class getRowWithColumns_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowWithColumns_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowWithColumns_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list184 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list184.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem185;
+ for (int _i186 = 0; _i186 < _list184.size; ++_i186)
+ {
+ _elem185 = new TRowResult();
+ _elem185.read(iprot);
+ struct.success.add(_elem185);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowWithColumns_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter187 : struct.success)
+ {
+ _iter187.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowWithColumns_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumns_resultTupleScheme getScheme() {
+ return new getRowWithColumns_resultTupleScheme();
+ }
+ }
+
+ private static class getRowWithColumns_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowWithColumns_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowWithColumns_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter188 : struct.success)
+ {
+ _iter188.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowWithColumns_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list189 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list189.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem190;
+ for (int _i191 = 0; _i191 < _list189.size; ++_i191)
+ {
+ _elem190 = new TRowResult();
+ _elem190.read(iprot);
+ struct.success.add(_elem190);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowTs_args implements org.apache.thrift.TBase<getRowTs_args, getRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowTs_argsTupleSchemeFactory();
+
+ /**
+ * name of the table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of the table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)3, "timestamp"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap);
+ }
+
+ public getRowTs_args() {
+ }
+
+ public getRowTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowTs_args(getRowTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRowTs_args deepCopy() {
+ return new getRowTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of the table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of the table
+ */
+ public getRowTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRowTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public getRowTs_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getRowTs_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public getRowTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRowTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowTs_args)
+ return this.equals((getRowTs_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowTs_argsStandardScheme getScheme() {
+ return new getRowTs_argsStandardScheme();
+ }
+ }
+
+ private static class getRowTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map192 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map192.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key193;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val194;
+ for (int _i195 = 0; _i195 < _map192.size; ++_i195)
+ {
+ _key193 = iprot.readBinary();
+ _val194 = iprot.readBinary();
+ struct.attributes.put(_key193, _val194);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter196 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter196.getKey());
+ oprot.writeBinary(_iter196.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowTs_argsTupleScheme getScheme() {
+ return new getRowTs_argsTupleScheme();
+ }
+ }
+
+ private static class getRowTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter197 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter197.getKey());
+ oprot.writeBinary(_iter197.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map198 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map198.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key199;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val200;
+ for (int _i201 = 0; _i201 < _map198.size; ++_i201)
+ {
+ _key199 = iprot.readBinary();
+ _val200 = iprot.readBinary();
+ struct.attributes.put(_key199, _val200);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowTs_result implements org.apache.thrift.TBase<getRowTs_result, getRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRowTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap);
+ }
+
+ public getRowTs_result() {
+ }
+
+ public getRowTs_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowTs_result(getRowTs_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRowTs_result deepCopy() {
+ return new getRowTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRowTs_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRowTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowTs_result)
+ return this.equals((getRowTs_result)that);
+ return false;
+ }
+
+ public boolean equals(getRowTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowTs_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowTs_resultStandardScheme getScheme() {
+ return new getRowTs_resultStandardScheme();
+ }
+ }
+
+ private static class getRowTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list202 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list202.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem203;
+ for (int _i204 = 0; _i204 < _list202.size; ++_i204)
+ {
+ _elem203 = new TRowResult();
+ _elem203.read(iprot);
+ struct.success.add(_elem203);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter205 : struct.success)
+ {
+ _iter205.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowTs_resultTupleScheme getScheme() {
+ return new getRowTs_resultTupleScheme();
+ }
+ }
+
+ private static class getRowTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter206 : struct.success)
+ {
+ _iter206.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list207 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list207.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem208;
+ for (int _i209 = 0; _i209 < _list207.size; ++_i209)
+ {
+ _elem208 = new TRowResult();
+ _elem208.read(iprot);
+ struct.success.add(_elem208);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowWithColumnsTs_args implements org.apache.thrift.TBase<getRowWithColumnsTs_args, getRowWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumnsTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowWithColumnsTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowWithColumnsTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * List of columns to return, null for all columns
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ public long timestamp; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * List of columns to return, null for all columns
+ */
+ COLUMNS((short)3, "columns"),
+ TIMESTAMP((short)4, "timestamp"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)5, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap);
+ }
+
+ public getRowWithColumnsTs_args() {
+ }
+
+ public getRowWithColumnsTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.util.List<java.nio.ByteBuffer> columns,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.columns = columns;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowWithColumnsTs_args(getRowWithColumnsTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRowWithColumnsTs_args deepCopy() {
+ return new getRowWithColumnsTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.columns = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getRowWithColumnsTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRowWithColumnsTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public getRowWithColumnsTs_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getRowWithColumnsTs_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ public getRowWithColumnsTs_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public getRowWithColumnsTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRowWithColumnsTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowWithColumnsTs_args)
+ return this.equals((getRowWithColumnsTs_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowWithColumnsTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowWithColumnsTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowWithColumnsTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowWithColumnsTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumnsTs_argsStandardScheme getScheme() {
+ return new getRowWithColumnsTs_argsStandardScheme();
+ }
+ }
+
+ private static class getRowWithColumnsTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowWithColumnsTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list210 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list210.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem211;
+ for (int _i212 = 0; _i212 < _list210.size; ++_i212)
+ {
+ _elem211 = iprot.readBinary();
+ struct.columns.add(_elem211);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map213 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map213.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key214;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val215;
+ for (int _i216 = 0; _i216 < _map213.size; ++_i216)
+ {
+ _key214 = iprot.readBinary();
+ _val215 = iprot.readBinary();
+ struct.attributes.put(_key214, _val215);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter217 : struct.columns)
+ {
+ oprot.writeBinary(_iter217);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter218 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter218.getKey());
+ oprot.writeBinary(_iter218.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowWithColumnsTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumnsTs_argsTupleScheme getScheme() {
+ return new getRowWithColumnsTs_argsTupleScheme();
+ }
+ }
+
+ private static class getRowWithColumnsTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowWithColumnsTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(3);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter219 : struct.columns)
+ {
+ oprot.writeBinary(_iter219);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter220 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter220.getKey());
+ oprot.writeBinary(_iter220.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list221 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list221.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem222;
+ for (int _i223 = 0; _i223 < _list221.size; ++_i223)
+ {
+ _elem222 = iprot.readBinary();
+ struct.columns.add(_elem222);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(4)) {
+ {
+ org.apache.thrift.protocol.TMap _map224 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map224.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key225;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val226;
+ for (int _i227 = 0; _i227 < _map224.size; ++_i227)
+ {
+ _key225 = iprot.readBinary();
+ _val226 = iprot.readBinary();
+ struct.attributes.put(_key225, _val226);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowWithColumnsTs_result implements org.apache.thrift.TBase<getRowWithColumnsTs_result, getRowWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumnsTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowWithColumnsTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowWithColumnsTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap);
+ }
+
+ public getRowWithColumnsTs_result() {
+ }
+
+ public getRowWithColumnsTs_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowWithColumnsTs_result(getRowWithColumnsTs_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRowWithColumnsTs_result deepCopy() {
+ return new getRowWithColumnsTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRowWithColumnsTs_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRowWithColumnsTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowWithColumnsTs_result)
+ return this.equals((getRowWithColumnsTs_result)that);
+ return false;
+ }
+
+ public boolean equals(getRowWithColumnsTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowWithColumnsTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowWithColumnsTs_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowWithColumnsTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumnsTs_resultStandardScheme getScheme() {
+ return new getRowWithColumnsTs_resultStandardScheme();
+ }
+ }
+
+ private static class getRowWithColumnsTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowWithColumnsTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list228 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list228.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem229;
+ for (int _i230 = 0; _i230 < _list228.size; ++_i230)
+ {
+ _elem229 = new TRowResult();
+ _elem229.read(iprot);
+ struct.success.add(_elem229);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter231 : struct.success)
+ {
+ _iter231.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowWithColumnsTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowWithColumnsTs_resultTupleScheme getScheme() {
+ return new getRowWithColumnsTs_resultTupleScheme();
+ }
+ }
+
+ private static class getRowWithColumnsTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowWithColumnsTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter232 : struct.success)
+ {
+ _iter232.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list233 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list233.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem234;
+ for (int _i235 = 0; _i235 < _list233.size; ++_i235)
+ {
+ _elem234 = new TRowResult();
+ _elem234.read(iprot);
+ struct.success.add(_elem234);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRows_args implements org.apache.thrift.TBase<getRows_args, getRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRows_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRows_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRows_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row keys
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row keys
+ */
+ ROWS((short)2, "rows"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)3, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROWS
+ return ROWS;
+ case 3: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRows_args.class, metaDataMap);
+ }
+
+ public getRows_args() {
+ }
+
+ public getRows_args(
+ java.nio.ByteBuffer tableName,
+ java.util.List<java.nio.ByteBuffer> rows,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.rows = rows;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRows_args(getRows_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRows()) {
+ java.util.List<java.nio.ByteBuffer> __this__rows = new java.util.ArrayList<java.nio.ByteBuffer>(other.rows.size());
+ for (java.nio.ByteBuffer other_element : other.rows) {
+ __this__rows.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.rows = __this__rows;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRows_args deepCopy() {
+ return new getRows_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.rows = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getRows_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRows_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowsSize() {
+ return (this.rows == null) ? 0 : this.rows.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getRowsIterator() {
+ return (this.rows == null) ? null : this.rows.iterator();
+ }
+
+ public void addToRows(java.nio.ByteBuffer elem) {
+ if (this.rows == null) {
+ this.rows = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.rows.add(elem);
+ }
+
+ /**
+ * row keys
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getRows() {
+ return this.rows;
+ }
+
+ /**
+ * row keys
+ */
+ public getRows_args setRows(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows) {
+ this.rows = rows;
+ return this;
+ }
+
+ public void unsetRows() {
+ this.rows = null;
+ }
+
+ /** Returns true if field rows is set (has been assigned a value) and false otherwise */
+ public boolean isSetRows() {
+ return this.rows != null;
+ }
+
+ public void setRowsIsSet(boolean value) {
+ if (!value) {
+ this.rows = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRows_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROWS:
+ if (value == null) {
+ unsetRows();
+ } else {
+ setRows((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROWS:
+ return getRows();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROWS:
+ return isSetRows();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRows_args)
+ return this.equals((getRows_args)that);
+ return false;
+ }
+
+ public boolean equals(getRows_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_rows = true && this.isSetRows();
+ boolean that_present_rows = true && that.isSetRows();
+ if (this_present_rows || that_present_rows) {
+ if (!(this_present_rows && that_present_rows))
+ return false;
+ if (!this.rows.equals(that.rows))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRows()) ? 131071 : 524287);
+ if (isSetRows())
+ hashCode = hashCode * 8191 + rows.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRows_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRows(), other.isSetRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRows()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, other.rows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRows_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("rows:");
+ if (this.rows == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.rows, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRows_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRows_argsStandardScheme getScheme() {
+ return new getRows_argsStandardScheme();
+ }
+ }
+
+ private static class getRows_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRows_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROWS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list236 = iprot.readListBegin();
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list236.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem237;
+ for (int _i238 = 0; _i238 < _list236.size; ++_i238)
+ {
+ _elem237 = iprot.readBinary();
+ struct.rows.add(_elem237);
+ }
+ iprot.readListEnd();
+ }
+ struct.setRowsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map239 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map239.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key240;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val241;
+ for (int _i242 = 0; _i242 < _map239.size; ++_i242)
+ {
+ _key240 = iprot.readBinary();
+ _val241 = iprot.readBinary();
+ struct.attributes.put(_key240, _val241);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRows_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.rows != null) {
+ oprot.writeFieldBegin(ROWS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size()));
+ for (java.nio.ByteBuffer _iter243 : struct.rows)
+ {
+ oprot.writeBinary(_iter243);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter244 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter244.getKey());
+ oprot.writeBinary(_iter244.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRows_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRows_argsTupleScheme getScheme() {
+ return new getRows_argsTupleScheme();
+ }
+ }
+
+ private static class getRows_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRows_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRows()) {
+ optionals.set(1);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRows()) {
+ {
+ oprot.writeI32(struct.rows.size());
+ for (java.nio.ByteBuffer _iter245 : struct.rows)
+ {
+ oprot.writeBinary(_iter245);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter246 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter246.getKey());
+ oprot.writeBinary(_iter246.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list247 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list247.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem248;
+ for (int _i249 = 0; _i249 < _list247.size; ++_i249)
+ {
+ _elem248 = iprot.readBinary();
+ struct.rows.add(_elem248);
+ }
+ }
+ struct.setRowsIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TMap _map250 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map250.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key251;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val252;
+ for (int _i253 = 0; _i253 < _map250.size; ++_i253)
+ {
+ _key251 = iprot.readBinary();
+ _val252 = iprot.readBinary();
+ struct.attributes.put(_key251, _val252);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRows_result implements org.apache.thrift.TBase<getRows_result, getRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRows_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRows_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRows_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRows_result.class, metaDataMap);
+ }
+
+ public getRows_result() {
+ }
+
+ public getRows_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRows_result(getRows_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRows_result deepCopy() {
+ return new getRows_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRows_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRows_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRows_result)
+ return this.equals((getRows_result)that);
+ return false;
+ }
+
+ public boolean equals(getRows_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRows_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRows_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRows_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRows_resultStandardScheme getScheme() {
+ return new getRows_resultStandardScheme();
+ }
+ }
+
+ private static class getRows_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRows_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list254 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list254.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem255;
+ for (int _i256 = 0; _i256 < _list254.size; ++_i256)
+ {
+ _elem255 = new TRowResult();
+ _elem255.read(iprot);
+ struct.success.add(_elem255);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRows_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter257 : struct.success)
+ {
+ _iter257.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRows_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRows_resultTupleScheme getScheme() {
+ return new getRows_resultTupleScheme();
+ }
+ }
+
+ private static class getRows_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRows_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter258 : struct.success)
+ {
+ _iter258.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list259 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list259.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem260;
+ for (int _i261 = 0; _i261 < _list259.size; ++_i261)
+ {
+ _elem260 = new TRowResult();
+ _elem260.read(iprot);
+ struct.success.add(_elem260);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowsWithColumns_args implements org.apache.thrift.TBase<getRowsWithColumns_args, getRowsWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumns_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowsWithColumns_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowsWithColumns_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row keys
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows; // required
+ /**
+ * List of columns to return, null for all columns
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row keys
+ */
+ ROWS((short)2, "rows"),
+ /**
+ * List of columns to return, null for all columns
+ */
+ COLUMNS((short)3, "columns"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROWS
+ return ROWS;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumns_args.class, metaDataMap);
+ }
+
+ public getRowsWithColumns_args() {
+ }
+
+ public getRowsWithColumns_args(
+ java.nio.ByteBuffer tableName,
+ java.util.List<java.nio.ByteBuffer> rows,
+ java.util.List<java.nio.ByteBuffer> columns,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.rows = rows;
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsWithColumns_args(getRowsWithColumns_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRows()) {
+ java.util.List<java.nio.ByteBuffer> __this__rows = new java.util.ArrayList<java.nio.ByteBuffer>(other.rows.size());
+ for (java.nio.ByteBuffer other_element : other.rows) {
+ __this__rows.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.rows = __this__rows;
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRowsWithColumns_args deepCopy() {
+ return new getRowsWithColumns_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.rows = null;
+ this.columns = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getRowsWithColumns_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRowsWithColumns_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowsSize() {
+ return (this.rows == null) ? 0 : this.rows.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getRowsIterator() {
+ return (this.rows == null) ? null : this.rows.iterator();
+ }
+
+ public void addToRows(java.nio.ByteBuffer elem) {
+ if (this.rows == null) {
+ this.rows = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.rows.add(elem);
+ }
+
+ /**
+ * row keys
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getRows() {
+ return this.rows;
+ }
+
+ /**
+ * row keys
+ */
+ public getRowsWithColumns_args setRows(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows) {
+ this.rows = rows;
+ return this;
+ }
+
+ public void unsetRows() {
+ this.rows = null;
+ }
+
+ /** Returns true if field rows is set (has been assigned a value) and false otherwise */
+ public boolean isSetRows() {
+ return this.rows != null;
+ }
+
+ public void setRowsIsSet(boolean value) {
+ if (!value) {
+ this.rows = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ public getRowsWithColumns_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRowsWithColumns_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROWS:
+ if (value == null) {
+ unsetRows();
+ } else {
+ setRows((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROWS:
+ return getRows();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROWS:
+ return isSetRows();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowsWithColumns_args)
+ return this.equals((getRowsWithColumns_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowsWithColumns_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_rows = true && this.isSetRows();
+ boolean that_present_rows = true && that.isSetRows();
+ if (this_present_rows || that_present_rows) {
+ if (!(this_present_rows && that_present_rows))
+ return false;
+ if (!this.rows.equals(that.rows))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRows()) ? 131071 : 524287);
+ if (isSetRows())
+ hashCode = hashCode * 8191 + rows.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowsWithColumns_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRows(), other.isSetRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRows()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, other.rows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowsWithColumns_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("rows:");
+ if (this.rows == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.rows, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowsWithColumns_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumns_argsStandardScheme getScheme() {
+ return new getRowsWithColumns_argsStandardScheme();
+ }
+ }
+
+ private static class getRowsWithColumns_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowsWithColumns_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowsWithColumns_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROWS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list262 = iprot.readListBegin();
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list262.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem263;
+ for (int _i264 = 0; _i264 < _list262.size; ++_i264)
+ {
+ _elem263 = iprot.readBinary();
+ struct.rows.add(_elem263);
+ }
+ iprot.readListEnd();
+ }
+ struct.setRowsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list265 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list265.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem266;
+ for (int _i267 = 0; _i267 < _list265.size; ++_i267)
+ {
+ _elem266 = iprot.readBinary();
+ struct.columns.add(_elem266);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map268 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map268.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key269;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val270;
+ for (int _i271 = 0; _i271 < _map268.size; ++_i271)
+ {
+ _key269 = iprot.readBinary();
+ _val270 = iprot.readBinary();
+ struct.attributes.put(_key269, _val270);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowsWithColumns_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.rows != null) {
+ oprot.writeFieldBegin(ROWS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size()));
+ for (java.nio.ByteBuffer _iter272 : struct.rows)
+ {
+ oprot.writeBinary(_iter272);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter273 : struct.columns)
+ {
+ oprot.writeBinary(_iter273);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter274 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter274.getKey());
+ oprot.writeBinary(_iter274.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowsWithColumns_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumns_argsTupleScheme getScheme() {
+ return new getRowsWithColumns_argsTupleScheme();
+ }
+ }
+
+ private static class getRowsWithColumns_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowsWithColumns_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumns_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRows()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRows()) {
+ {
+ oprot.writeI32(struct.rows.size());
+ for (java.nio.ByteBuffer _iter275 : struct.rows)
+ {
+ oprot.writeBinary(_iter275);
+ }
+ }
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter276 : struct.columns)
+ {
+ oprot.writeBinary(_iter276);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter277 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter277.getKey());
+ oprot.writeBinary(_iter277.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumns_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list278 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list278.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem279;
+ for (int _i280 = 0; _i280 < _list278.size; ++_i280)
+ {
+ _elem279 = iprot.readBinary();
+ struct.rows.add(_elem279);
+ }
+ }
+ struct.setRowsIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list281 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list281.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem282;
+ for (int _i283 = 0; _i283 < _list281.size; ++_i283)
+ {
+ _elem282 = iprot.readBinary();
+ struct.columns.add(_elem282);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map284 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map284.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key285;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val286;
+ for (int _i287 = 0; _i287 < _map284.size; ++_i287)
+ {
+ _key285 = iprot.readBinary();
+ _val286 = iprot.readBinary();
+ struct.attributes.put(_key285, _val286);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowsWithColumns_result implements org.apache.thrift.TBase<getRowsWithColumns_result, getRowsWithColumns_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumns_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowsWithColumns_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowsWithColumns_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumns_result.class, metaDataMap);
+ }
+
+ public getRowsWithColumns_result() {
+ }
+
+ public getRowsWithColumns_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsWithColumns_result(getRowsWithColumns_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRowsWithColumns_result deepCopy() {
+ return new getRowsWithColumns_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRowsWithColumns_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRowsWithColumns_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowsWithColumns_result)
+ return this.equals((getRowsWithColumns_result)that);
+ return false;
+ }
+
+ public boolean equals(getRowsWithColumns_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowsWithColumns_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowsWithColumns_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowsWithColumns_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumns_resultStandardScheme getScheme() {
+ return new getRowsWithColumns_resultStandardScheme();
+ }
+ }
+
+ private static class getRowsWithColumns_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowsWithColumns_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowsWithColumns_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list288 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list288.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem289;
+ for (int _i290 = 0; _i290 < _list288.size; ++_i290)
+ {
+ _elem289 = new TRowResult();
+ _elem289.read(iprot);
+ struct.success.add(_elem289);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowsWithColumns_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter291 : struct.success)
+ {
+ _iter291.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowsWithColumns_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumns_resultTupleScheme getScheme() {
+ return new getRowsWithColumns_resultTupleScheme();
+ }
+ }
+
+ private static class getRowsWithColumns_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowsWithColumns_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumns_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter292 : struct.success)
+ {
+ _iter292.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumns_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list293 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list293.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem294;
+ for (int _i295 = 0; _i295 < _list293.size; ++_i295)
+ {
+ _elem294 = new TRowResult();
+ _elem294.read(iprot);
+ struct.success.add(_elem294);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowsTs_args implements org.apache.thrift.TBase<getRowsTs_args, getRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowsTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowsTs_argsTupleSchemeFactory();
+
+ /**
+ * name of the table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row keys
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of the table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row keys
+ */
+ ROWS((short)2, "rows"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)3, "timestamp"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROWS
+ return ROWS;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsTs_args.class, metaDataMap);
+ }
+
+ public getRowsTs_args() {
+ }
+
+ public getRowsTs_args(
+ java.nio.ByteBuffer tableName,
+ java.util.List<java.nio.ByteBuffer> rows,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.rows = rows;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsTs_args(getRowsTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRows()) {
+ java.util.List<java.nio.ByteBuffer> __this__rows = new java.util.ArrayList<java.nio.ByteBuffer>(other.rows.size());
+ for (java.nio.ByteBuffer other_element : other.rows) {
+ __this__rows.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.rows = __this__rows;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRowsTs_args deepCopy() {
+ return new getRowsTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.rows = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of the table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of the table
+ */
+ public getRowsTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRowsTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowsSize() {
+ return (this.rows == null) ? 0 : this.rows.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getRowsIterator() {
+ return (this.rows == null) ? null : this.rows.iterator();
+ }
+
+ public void addToRows(java.nio.ByteBuffer elem) {
+ if (this.rows == null) {
+ this.rows = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.rows.add(elem);
+ }
+
+ /**
+ * row keys
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getRows() {
+ return this.rows;
+ }
+
+ /**
+ * row keys
+ */
+ public getRowsTs_args setRows(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows) {
+ this.rows = rows;
+ return this;
+ }
+
+ public void unsetRows() {
+ this.rows = null;
+ }
+
+ /** Returns true if field rows is set (has been assigned a value) and false otherwise */
+ public boolean isSetRows() {
+ return this.rows != null;
+ }
+
+ public void setRowsIsSet(boolean value) {
+ if (!value) {
+ this.rows = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public getRowsTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRowsTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROWS:
+ if (value == null) {
+ unsetRows();
+ } else {
+ setRows((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROWS:
+ return getRows();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROWS:
+ return isSetRows();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowsTs_args)
+ return this.equals((getRowsTs_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowsTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_rows = true && this.isSetRows();
+ boolean that_present_rows = true && that.isSetRows();
+ if (this_present_rows || that_present_rows) {
+ if (!(this_present_rows && that_present_rows))
+ return false;
+ if (!this.rows.equals(that.rows))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRows()) ? 131071 : 524287);
+ if (isSetRows())
+ hashCode = hashCode * 8191 + rows.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowsTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRows(), other.isSetRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRows()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, other.rows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowsTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("rows:");
+ if (this.rows == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.rows, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowsTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsTs_argsStandardScheme getScheme() {
+ return new getRowsTs_argsStandardScheme();
+ }
+ }
+
+ private static class getRowsTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowsTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROWS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list296 = iprot.readListBegin();
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list296.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem297;
+ for (int _i298 = 0; _i298 < _list296.size; ++_i298)
+ {
+ _elem297 = iprot.readBinary();
+ struct.rows.add(_elem297);
+ }
+ iprot.readListEnd();
+ }
+ struct.setRowsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map299 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map299.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key300;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val301;
+ for (int _i302 = 0; _i302 < _map299.size; ++_i302)
+ {
+ _key300 = iprot.readBinary();
+ _val301 = iprot.readBinary();
+ struct.attributes.put(_key300, _val301);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowsTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.rows != null) {
+ oprot.writeFieldBegin(ROWS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size()));
+ for (java.nio.ByteBuffer _iter303 : struct.rows)
+ {
+ oprot.writeBinary(_iter303);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter304 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter304.getKey());
+ oprot.writeBinary(_iter304.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowsTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsTs_argsTupleScheme getScheme() {
+ return new getRowsTs_argsTupleScheme();
+ }
+ }
+
+ private static class getRowsTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowsTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRows()) {
+ optionals.set(1);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRows()) {
+ {
+ oprot.writeI32(struct.rows.size());
+ for (java.nio.ByteBuffer _iter305 : struct.rows)
+ {
+ oprot.writeBinary(_iter305);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter306 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter306.getKey());
+ oprot.writeBinary(_iter306.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list307 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list307.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem308;
+ for (int _i309 = 0; _i309 < _list307.size; ++_i309)
+ {
+ _elem308 = iprot.readBinary();
+ struct.rows.add(_elem308);
+ }
+ }
+ struct.setRowsIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map310 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map310.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key311;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val312;
+ for (int _i313 = 0; _i313 < _map310.size; ++_i313)
+ {
+ _key311 = iprot.readBinary();
+ _val312 = iprot.readBinary();
+ struct.attributes.put(_key311, _val312);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowsTs_result implements org.apache.thrift.TBase<getRowsTs_result, getRowsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowsTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowsTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsTs_result.class, metaDataMap);
+ }
+
+ public getRowsTs_result() {
+ }
+
+ public getRowsTs_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsTs_result(getRowsTs_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRowsTs_result deepCopy() {
+ return new getRowsTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRowsTs_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRowsTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowsTs_result)
+ return this.equals((getRowsTs_result)that);
+ return false;
+ }
+
+ public boolean equals(getRowsTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowsTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowsTs_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowsTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsTs_resultStandardScheme getScheme() {
+ return new getRowsTs_resultStandardScheme();
+ }
+ }
+
+ private static class getRowsTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowsTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list314 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list314.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem315;
+ for (int _i316 = 0; _i316 < _list314.size; ++_i316)
+ {
+ _elem315 = new TRowResult();
+ _elem315.read(iprot);
+ struct.success.add(_elem315);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowsTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter317 : struct.success)
+ {
+ _iter317.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowsTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsTs_resultTupleScheme getScheme() {
+ return new getRowsTs_resultTupleScheme();
+ }
+ }
+
+ private static class getRowsTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowsTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter318 : struct.success)
+ {
+ _iter318.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list319 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list319.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem320;
+ for (int _i321 = 0; _i321 < _list319.size; ++_i321)
+ {
+ _elem320 = new TRowResult();
+ _elem320.read(iprot);
+ struct.success.add(_elem320);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowsWithColumnsTs_args implements org.apache.thrift.TBase<getRowsWithColumnsTs_args, getRowsWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumnsTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowsWithColumnsTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowsWithColumnsTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row keys
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows; // required
+ /**
+ * List of columns to return, null for all columns
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ public long timestamp; // required
+ /**
+ * Get attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row keys
+ */
+ ROWS((short)2, "rows"),
+ /**
+ * List of columns to return, null for all columns
+ */
+ COLUMNS((short)3, "columns"),
+ TIMESTAMP((short)4, "timestamp"),
+ /**
+ * Get attributes
+ */
+ ATTRIBUTES((short)5, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROWS
+ return ROWS;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_args.class, metaDataMap);
+ }
+
+ public getRowsWithColumnsTs_args() {
+ }
+
+ public getRowsWithColumnsTs_args(
+ java.nio.ByteBuffer tableName,
+ java.util.List<java.nio.ByteBuffer> rows,
+ java.util.List<java.nio.ByteBuffer> columns,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.rows = rows;
+ this.columns = columns;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsWithColumnsTs_args(getRowsWithColumnsTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRows()) {
+ java.util.List<java.nio.ByteBuffer> __this__rows = new java.util.ArrayList<java.nio.ByteBuffer>(other.rows.size());
+ for (java.nio.ByteBuffer other_element : other.rows) {
+ __this__rows.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.rows = __this__rows;
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public getRowsWithColumnsTs_args deepCopy() {
+ return new getRowsWithColumnsTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.rows = null;
+ this.columns = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public getRowsWithColumnsTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public getRowsWithColumnsTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowsSize() {
+ return (this.rows == null) ? 0 : this.rows.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getRowsIterator() {
+ return (this.rows == null) ? null : this.rows.iterator();
+ }
+
+ public void addToRows(java.nio.ByteBuffer elem) {
+ if (this.rows == null) {
+ this.rows = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.rows.add(elem);
+ }
+
+ /**
+ * row keys
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getRows() {
+ return this.rows;
+ }
+
+ /**
+ * row keys
+ */
+ public getRowsWithColumnsTs_args setRows(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> rows) {
+ this.rows = rows;
+ return this;
+ }
+
+ public void unsetRows() {
+ this.rows = null;
+ }
+
+ /** Returns true if field rows is set (has been assigned a value) and false otherwise */
+ public boolean isSetRows() {
+ return this.rows != null;
+ }
+
+ public void setRowsIsSet(boolean value) {
+ if (!value) {
+ this.rows = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * List of columns to return, null for all columns
+ */
+ public getRowsWithColumnsTs_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public getRowsWithColumnsTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Get attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Get attributes
+ */
+ public getRowsWithColumnsTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROWS:
+ if (value == null) {
+ unsetRows();
+ } else {
+ setRows((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROWS:
+ return getRows();
+
+ case COLUMNS:
+ return getColumns();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROWS:
+ return isSetRows();
+ case COLUMNS:
+ return isSetColumns();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowsWithColumnsTs_args)
+ return this.equals((getRowsWithColumnsTs_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowsWithColumnsTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_rows = true && this.isSetRows();
+ boolean that_present_rows = true && that.isSetRows();
+ if (this_present_rows || that_present_rows) {
+ if (!(this_present_rows && that_present_rows))
+ return false;
+ if (!this.rows.equals(that.rows))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRows()) ? 131071 : 524287);
+ if (isSetRows())
+ hashCode = hashCode * 8191 + rows.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowsWithColumnsTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRows(), other.isSetRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRows()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, other.rows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowsWithColumnsTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("rows:");
+ if (this.rows == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.rows, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowsWithColumnsTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumnsTs_argsStandardScheme getScheme() {
+ return new getRowsWithColumnsTs_argsStandardScheme();
+ }
+ }
+
+ private static class getRowsWithColumnsTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowsWithColumnsTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowsWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROWS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list322 = iprot.readListBegin();
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list322.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem323;
+ for (int _i324 = 0; _i324 < _list322.size; ++_i324)
+ {
+ _elem323 = iprot.readBinary();
+ struct.rows.add(_elem323);
+ }
+ iprot.readListEnd();
+ }
+ struct.setRowsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list325 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list325.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem326;
+ for (int _i327 = 0; _i327 < _list325.size; ++_i327)
+ {
+ _elem326 = iprot.readBinary();
+ struct.columns.add(_elem326);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map328 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map328.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key329;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val330;
+ for (int _i331 = 0; _i331 < _map328.size; ++_i331)
+ {
+ _key329 = iprot.readBinary();
+ _val330 = iprot.readBinary();
+ struct.attributes.put(_key329, _val330);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowsWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.rows != null) {
+ oprot.writeFieldBegin(ROWS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.rows.size()));
+ for (java.nio.ByteBuffer _iter332 : struct.rows)
+ {
+ oprot.writeBinary(_iter332);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter333 : struct.columns)
+ {
+ oprot.writeBinary(_iter333);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter334 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter334.getKey());
+ oprot.writeBinary(_iter334.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowsWithColumnsTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumnsTs_argsTupleScheme getScheme() {
+ return new getRowsWithColumnsTs_argsTupleScheme();
+ }
+ }
+
+ private static class getRowsWithColumnsTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowsWithColumnsTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRows()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(3);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRows()) {
+ {
+ oprot.writeI32(struct.rows.size());
+ for (java.nio.ByteBuffer _iter335 : struct.rows)
+ {
+ oprot.writeBinary(_iter335);
+ }
+ }
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter336 : struct.columns)
+ {
+ oprot.writeBinary(_iter336);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter337 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter337.getKey());
+ oprot.writeBinary(_iter337.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumnsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list338 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.rows = new java.util.ArrayList<java.nio.ByteBuffer>(_list338.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem339;
+ for (int _i340 = 0; _i340 < _list338.size; ++_i340)
+ {
+ _elem339 = iprot.readBinary();
+ struct.rows.add(_elem339);
+ }
+ }
+ struct.setRowsIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list341 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list341.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem342;
+ for (int _i343 = 0; _i343 < _list341.size; ++_i343)
+ {
+ _elem342 = iprot.readBinary();
+ struct.columns.add(_elem342);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(4)) {
+ {
+ org.apache.thrift.protocol.TMap _map344 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map344.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key345;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val346;
+ for (int _i347 = 0; _i347 < _map344.size; ++_i347)
+ {
+ _key345 = iprot.readBinary();
+ _val346 = iprot.readBinary();
+ struct.attributes.put(_key345, _val346);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRowsWithColumnsTs_result implements org.apache.thrift.TBase<getRowsWithColumnsTs_result, getRowsWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumnsTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRowsWithColumnsTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRowsWithColumnsTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_result.class, metaDataMap);
+ }
+
+ public getRowsWithColumnsTs_result() {
+ }
+
+ public getRowsWithColumnsTs_result(
+ java.util.List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsWithColumnsTs_result(getRowsWithColumnsTs_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRowsWithColumnsTs_result deepCopy() {
+ return new getRowsWithColumnsTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRowsWithColumnsTs_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRowsWithColumnsTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRowsWithColumnsTs_result)
+ return this.equals((getRowsWithColumnsTs_result)that);
+ return false;
+ }
+
+ public boolean equals(getRowsWithColumnsTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRowsWithColumnsTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRowsWithColumnsTs_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRowsWithColumnsTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumnsTs_resultStandardScheme getScheme() {
+ return new getRowsWithColumnsTs_resultStandardScheme();
+ }
+ }
+
+ private static class getRowsWithColumnsTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRowsWithColumnsTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRowsWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list348 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list348.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem349;
+ for (int _i350 = 0; _i350 < _list348.size; ++_i350)
+ {
+ _elem349 = new TRowResult();
+ _elem349.read(iprot);
+ struct.success.add(_elem349);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRowsWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter351 : struct.success)
+ {
+ _iter351.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRowsWithColumnsTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRowsWithColumnsTs_resultTupleScheme getScheme() {
+ return new getRowsWithColumnsTs_resultTupleScheme();
+ }
+ }
+
+ private static class getRowsWithColumnsTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRowsWithColumnsTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter352 : struct.success)
+ {
+ _iter352.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRowsWithColumnsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list353 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list353.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem354;
+ for (int _i355 = 0; _i355 < _list353.size; ++_i355)
+ {
+ _elem354 = new TRowResult();
+ _elem354.read(iprot);
+ struct.success.add(_elem354);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRow_args implements org.apache.thrift.TBase<mutateRow_args, mutateRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRow_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRow_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * list of mutation commands
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<Mutation> mutations; // required
+ /**
+ * Mutation attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * list of mutation commands
+ */
+ MUTATIONS((short)3, "mutations"),
+ /**
+ * Mutation attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // MUTATIONS
+ return MUTATIONS;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
+ }
+
+ public mutateRow_args() {
+ }
+
+ public mutateRow_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.util.List<Mutation> mutations,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.mutations = mutations;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRow_args(mutateRow_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetMutations()) {
+ java.util.List<Mutation> __this__mutations = new java.util.ArrayList<Mutation>(other.mutations.size());
+ for (Mutation other_element : other.mutations) {
+ __this__mutations.add(new Mutation(other_element));
+ }
+ this.mutations = __this__mutations;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public mutateRow_args deepCopy() {
+ return new mutateRow_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.mutations = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public mutateRow_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public mutateRow_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public mutateRow_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public mutateRow_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getMutationsSize() {
+ return (this.mutations == null) ? 0 : this.mutations.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<Mutation> getMutationsIterator() {
+ return (this.mutations == null) ? null : this.mutations.iterator();
+ }
+
+ public void addToMutations(Mutation elem) {
+ if (this.mutations == null) {
+ this.mutations = new java.util.ArrayList<Mutation>();
+ }
+ this.mutations.add(elem);
+ }
+
+ /**
+ * list of mutation commands
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<Mutation> getMutations() {
+ return this.mutations;
+ }
+
+ /**
+ * list of mutation commands
+ */
+ public mutateRow_args setMutations(@org.apache.thrift.annotation.Nullable java.util.List<Mutation> mutations) {
+ this.mutations = mutations;
+ return this;
+ }
+
+ public void unsetMutations() {
+ this.mutations = null;
+ }
+
+ /** Returns true if field mutations is set (has been assigned a value) and false otherwise */
+ public boolean isSetMutations() {
+ return this.mutations != null;
+ }
+
+ public void setMutationsIsSet(boolean value) {
+ if (!value) {
+ this.mutations = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Mutation attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Mutation attributes
+ */
+ public mutateRow_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case MUTATIONS:
+ if (value == null) {
+ unsetMutations();
+ } else {
+ setMutations((java.util.List<Mutation>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case MUTATIONS:
+ return getMutations();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case MUTATIONS:
+ return isSetMutations();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRow_args)
+ return this.equals((mutateRow_args)that);
+ return false;
+ }
+
+ public boolean equals(mutateRow_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_mutations = true && this.isSetMutations();
+ boolean that_present_mutations = true && that.isSetMutations();
+ if (this_present_mutations || that_present_mutations) {
+ if (!(this_present_mutations && that_present_mutations))
+ return false;
+ if (!this.mutations.equals(that.mutations))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetMutations()) ? 131071 : 524287);
+ if (isSetMutations())
+ hashCode = hashCode * 8191 + mutations.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRow_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMutations(), other.isSetMutations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMutations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutations, other.mutations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRow_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("mutations:");
+ if (this.mutations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.mutations);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRow_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_argsStandardScheme getScheme() {
+ return new mutateRow_argsStandardScheme();
+ }
+ }
+
+ private static class mutateRow_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRow_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // MUTATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list356 = iprot.readListBegin();
+ struct.mutations = new java.util.ArrayList<Mutation>(_list356.size);
+ @org.apache.thrift.annotation.Nullable Mutation _elem357;
+ for (int _i358 = 0; _i358 < _list356.size; ++_i358)
+ {
+ _elem357 = new Mutation();
+ _elem357.read(iprot);
+ struct.mutations.add(_elem357);
+ }
+ iprot.readListEnd();
+ }
+ struct.setMutationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map359 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map359.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key360;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val361;
+ for (int _i362 = 0; _i362 < _map359.size; ++_i362)
+ {
+ _key360 = iprot.readBinary();
+ _val361 = iprot.readBinary();
+ struct.attributes.put(_key360, _val361);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.mutations != null) {
+ oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mutations.size()));
+ for (Mutation _iter363 : struct.mutations)
+ {
+ _iter363.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter364 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter364.getKey());
+ oprot.writeBinary(_iter364.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRow_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_argsTupleScheme getScheme() {
+ return new mutateRow_argsTupleScheme();
+ }
+ }
+
+ private static class mutateRow_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRow_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetMutations()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetMutations()) {
+ {
+ oprot.writeI32(struct.mutations.size());
+ for (Mutation _iter365 : struct.mutations)
+ {
+ _iter365.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter366 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter366.getKey());
+ oprot.writeBinary(_iter366.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list367 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.mutations = new java.util.ArrayList<Mutation>(_list367.size);
+ @org.apache.thrift.annotation.Nullable Mutation _elem368;
+ for (int _i369 = 0; _i369 < _list367.size; ++_i369)
+ {
+ _elem368 = new Mutation();
+ _elem368.read(iprot);
+ struct.mutations.add(_elem368);
+ }
+ }
+ struct.setMutationsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map370 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map370.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key371;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val372;
+ for (int _i373 = 0; _i373 < _map370.size; ++_i373)
+ {
+ _key371 = iprot.readBinary();
+ _val372 = iprot.readBinary();
+ struct.attributes.put(_key371, _val372);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRow_result implements org.apache.thrift.TBase<mutateRow_result, mutateRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRow_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRow_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
+ }
+
+ public mutateRow_result() {
+ }
+
+ public mutateRow_result(
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRow_result(mutateRow_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public mutateRow_result deepCopy() {
+ return new mutateRow_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ this.ia = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public mutateRow_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public mutateRow_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRow_result)
+ return this.equals((mutateRow_result)that);
+ return false;
+ }
+
+ public boolean equals(mutateRow_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRow_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRow_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRow_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_resultStandardScheme getScheme() {
+ return new mutateRow_resultStandardScheme();
+ }
+ }
+
+ private static class mutateRow_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRow_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRow_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_resultTupleScheme getScheme() {
+ return new mutateRow_resultTupleScheme();
+ }
+ }
+
+ private static class mutateRow_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRow_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRowTs_args implements org.apache.thrift.TBase<mutateRowTs_args, mutateRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRowTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRowTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * list of mutation commands
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<Mutation> mutations; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Mutation attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * list of mutation commands
+ */
+ MUTATIONS((short)3, "mutations"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)4, "timestamp"),
+ /**
+ * Mutation attributes
+ */
+ ATTRIBUTES((short)5, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // MUTATIONS
+ return MUTATIONS;
+ case 4: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowTs_args.class, metaDataMap);
+ }
+
+ public mutateRowTs_args() {
+ }
+
+ public mutateRowTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.util.List<Mutation> mutations,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.mutations = mutations;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRowTs_args(mutateRowTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetMutations()) {
+ java.util.List<Mutation> __this__mutations = new java.util.ArrayList<Mutation>(other.mutations.size());
+ for (Mutation other_element : other.mutations) {
+ __this__mutations.add(new Mutation(other_element));
+ }
+ this.mutations = __this__mutations;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public mutateRowTs_args deepCopy() {
+ return new mutateRowTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.mutations = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public mutateRowTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public mutateRowTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public mutateRowTs_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public mutateRowTs_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getMutationsSize() {
+ return (this.mutations == null) ? 0 : this.mutations.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<Mutation> getMutationsIterator() {
+ return (this.mutations == null) ? null : this.mutations.iterator();
+ }
+
+ public void addToMutations(Mutation elem) {
+ if (this.mutations == null) {
+ this.mutations = new java.util.ArrayList<Mutation>();
+ }
+ this.mutations.add(elem);
+ }
+
+ /**
+ * list of mutation commands
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<Mutation> getMutations() {
+ return this.mutations;
+ }
+
+ /**
+ * list of mutation commands
+ */
+ public mutateRowTs_args setMutations(@org.apache.thrift.annotation.Nullable java.util.List<Mutation> mutations) {
+ this.mutations = mutations;
+ return this;
+ }
+
+ public void unsetMutations() {
+ this.mutations = null;
+ }
+
+ /** Returns true if field mutations is set (has been assigned a value) and false otherwise */
+ public boolean isSetMutations() {
+ return this.mutations != null;
+ }
+
+ public void setMutationsIsSet(boolean value) {
+ if (!value) {
+ this.mutations = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public mutateRowTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Mutation attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Mutation attributes
+ */
+ public mutateRowTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case MUTATIONS:
+ if (value == null) {
+ unsetMutations();
+ } else {
+ setMutations((java.util.List<Mutation>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case MUTATIONS:
+ return getMutations();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case MUTATIONS:
+ return isSetMutations();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRowTs_args)
+ return this.equals((mutateRowTs_args)that);
+ return false;
+ }
+
+ public boolean equals(mutateRowTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_mutations = true && this.isSetMutations();
+ boolean that_present_mutations = true && that.isSetMutations();
+ if (this_present_mutations || that_present_mutations) {
+ if (!(this_present_mutations && that_present_mutations))
+ return false;
+ if (!this.mutations.equals(that.mutations))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetMutations()) ? 131071 : 524287);
+ if (isSetMutations())
+ hashCode = hashCode * 8191 + mutations.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRowTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMutations(), other.isSetMutations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMutations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutations, other.mutations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRowTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("mutations:");
+ if (this.mutations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.mutations);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRowTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowTs_argsStandardScheme getScheme() {
+ return new mutateRowTs_argsStandardScheme();
+ }
+ }
+
+ private static class mutateRowTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRowTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // MUTATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list374 = iprot.readListBegin();
+ struct.mutations = new java.util.ArrayList<Mutation>(_list374.size);
+ @org.apache.thrift.annotation.Nullable Mutation _elem375;
+ for (int _i376 = 0; _i376 < _list374.size; ++_i376)
+ {
+ _elem375 = new Mutation();
+ _elem375.read(iprot);
+ struct.mutations.add(_elem375);
+ }
+ iprot.readListEnd();
+ }
+ struct.setMutationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map377 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map377.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key378;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val379;
+ for (int _i380 = 0; _i380 < _map377.size; ++_i380)
+ {
+ _key378 = iprot.readBinary();
+ _val379 = iprot.readBinary();
+ struct.attributes.put(_key378, _val379);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRowTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.mutations != null) {
+ oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mutations.size()));
+ for (Mutation _iter381 : struct.mutations)
+ {
+ _iter381.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter382 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter382.getKey());
+ oprot.writeBinary(_iter382.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRowTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowTs_argsTupleScheme getScheme() {
+ return new mutateRowTs_argsTupleScheme();
+ }
+ }
+
+ private static class mutateRowTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRowTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetMutations()) {
+ optionals.set(2);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(3);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetMutations()) {
+ {
+ oprot.writeI32(struct.mutations.size());
+ for (Mutation _iter383 : struct.mutations)
+ {
+ _iter383.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter384 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter384.getKey());
+ oprot.writeBinary(_iter384.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list385 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.mutations = new java.util.ArrayList<Mutation>(_list385.size);
+ @org.apache.thrift.annotation.Nullable Mutation _elem386;
+ for (int _i387 = 0; _i387 < _list385.size; ++_i387)
+ {
+ _elem386 = new Mutation();
+ _elem386.read(iprot);
+ struct.mutations.add(_elem386);
+ }
+ }
+ struct.setMutationsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(4)) {
+ {
+ org.apache.thrift.protocol.TMap _map388 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map388.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key389;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val390;
+ for (int _i391 = 0; _i391 < _map388.size; ++_i391)
+ {
+ _key389 = iprot.readBinary();
+ _val390 = iprot.readBinary();
+ struct.attributes.put(_key389, _val390);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRowTs_result implements org.apache.thrift.TBase<mutateRowTs_result, mutateRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRowTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRowTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowTs_result.class, metaDataMap);
+ }
+
+ public mutateRowTs_result() {
+ }
+
+ public mutateRowTs_result(
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRowTs_result(mutateRowTs_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public mutateRowTs_result deepCopy() {
+ return new mutateRowTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ this.ia = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public mutateRowTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public mutateRowTs_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRowTs_result)
+ return this.equals((mutateRowTs_result)that);
+ return false;
+ }
+
+ public boolean equals(mutateRowTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRowTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRowTs_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRowTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowTs_resultStandardScheme getScheme() {
+ return new mutateRowTs_resultStandardScheme();
+ }
+ }
+
+ private static class mutateRowTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRowTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRowTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRowTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowTs_resultTupleScheme getScheme() {
+ return new mutateRowTs_resultTupleScheme();
+ }
+ }
+
+ private static class mutateRowTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRowTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRows_args implements org.apache.thrift.TBase<mutateRows_args, mutateRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRows_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRows_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * list of row batches
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<BatchMutation> rowBatches; // required
+ /**
+ * Mutation attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * list of row batches
+ */
+ ROW_BATCHES((short)2, "rowBatches"),
+ /**
+ * Mutation attributes
+ */
+ ATTRIBUTES((short)3, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW_BATCHES
+ return ROW_BATCHES;
+ case 3: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRows_args.class, metaDataMap);
+ }
+
+ public mutateRows_args() {
+ }
+
+ public mutateRows_args(
+ java.nio.ByteBuffer tableName,
+ java.util.List<BatchMutation> rowBatches,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.rowBatches = rowBatches;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRows_args(mutateRows_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRowBatches()) {
+ java.util.List<BatchMutation> __this__rowBatches = new java.util.ArrayList<BatchMutation>(other.rowBatches.size());
+ for (BatchMutation other_element : other.rowBatches) {
+ __this__rowBatches.add(new BatchMutation(other_element));
+ }
+ this.rowBatches = __this__rowBatches;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public mutateRows_args deepCopy() {
+ return new mutateRows_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.rowBatches = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public mutateRows_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public mutateRows_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowBatchesSize() {
+ return (this.rowBatches == null) ? 0 : this.rowBatches.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
+ return (this.rowBatches == null) ? null : this.rowBatches.iterator();
+ }
+
+ public void addToRowBatches(BatchMutation elem) {
+ if (this.rowBatches == null) {
+ this.rowBatches = new java.util.ArrayList<BatchMutation>();
+ }
+ this.rowBatches.add(elem);
+ }
+
+ /**
+ * list of row batches
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<BatchMutation> getRowBatches() {
+ return this.rowBatches;
+ }
+
+ /**
+ * list of row batches
+ */
+ public mutateRows_args setRowBatches(@org.apache.thrift.annotation.Nullable java.util.List<BatchMutation> rowBatches) {
+ this.rowBatches = rowBatches;
+ return this;
+ }
+
+ public void unsetRowBatches() {
+ this.rowBatches = null;
+ }
+
+ /** Returns true if field rowBatches is set (has been assigned a value) and false otherwise */
+ public boolean isSetRowBatches() {
+ return this.rowBatches != null;
+ }
+
+ public void setRowBatchesIsSet(boolean value) {
+ if (!value) {
+ this.rowBatches = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Mutation attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Mutation attributes
+ */
+ public mutateRows_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW_BATCHES:
+ if (value == null) {
+ unsetRowBatches();
+ } else {
+ setRowBatches((java.util.List<BatchMutation>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW_BATCHES:
+ return getRowBatches();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW_BATCHES:
+ return isSetRowBatches();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRows_args)
+ return this.equals((mutateRows_args)that);
+ return false;
+ }
+
+ public boolean equals(mutateRows_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_rowBatches = true && this.isSetRowBatches();
+ boolean that_present_rowBatches = true && that.isSetRowBatches();
+ if (this_present_rowBatches || that_present_rowBatches) {
+ if (!(this_present_rowBatches && that_present_rowBatches))
+ return false;
+ if (!this.rowBatches.equals(that.rowBatches))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRowBatches()) ? 131071 : 524287);
+ if (isSetRowBatches())
+ hashCode = hashCode * 8191 + rowBatches.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRows_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRowBatches(), other.isSetRowBatches());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRowBatches()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowBatches, other.rowBatches);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRows_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("rowBatches:");
+ if (this.rowBatches == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.rowBatches);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRows_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRows_argsStandardScheme getScheme() {
+ return new mutateRows_argsStandardScheme();
+ }
+ }
+
+ private static class mutateRows_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRows_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW_BATCHES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list392 = iprot.readListBegin();
+ struct.rowBatches = new java.util.ArrayList<BatchMutation>(_list392.size);
+ @org.apache.thrift.annotation.Nullable BatchMutation _elem393;
+ for (int _i394 = 0; _i394 < _list392.size; ++_i394)
+ {
+ _elem393 = new BatchMutation();
+ _elem393.read(iprot);
+ struct.rowBatches.add(_elem393);
+ }
+ iprot.readListEnd();
+ }
+ struct.setRowBatchesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map395 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map395.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key396;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val397;
+ for (int _i398 = 0; _i398 < _map395.size; ++_i398)
+ {
+ _key396 = iprot.readBinary();
+ _val397 = iprot.readBinary();
+ struct.attributes.put(_key396, _val397);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRows_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.rowBatches != null) {
+ oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.rowBatches.size()));
+ for (BatchMutation _iter399 : struct.rowBatches)
+ {
+ _iter399.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter400 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter400.getKey());
+ oprot.writeBinary(_iter400.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRows_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRows_argsTupleScheme getScheme() {
+ return new mutateRows_argsTupleScheme();
+ }
+ }
+
+ private static class mutateRows_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRows_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRowBatches()) {
+ optionals.set(1);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRowBatches()) {
+ {
+ oprot.writeI32(struct.rowBatches.size());
+ for (BatchMutation _iter401 : struct.rowBatches)
+ {
+ _iter401.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter402 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter402.getKey());
+ oprot.writeBinary(_iter402.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list403 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.rowBatches = new java.util.ArrayList<BatchMutation>(_list403.size);
+ @org.apache.thrift.annotation.Nullable BatchMutation _elem404;
+ for (int _i405 = 0; _i405 < _list403.size; ++_i405)
+ {
+ _elem404 = new BatchMutation();
+ _elem404.read(iprot);
+ struct.rowBatches.add(_elem404);
+ }
+ }
+ struct.setRowBatchesIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TMap _map406 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map406.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key407;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val408;
+ for (int _i409 = 0; _i409 < _map406.size; ++_i409)
+ {
+ _key407 = iprot.readBinary();
+ _val408 = iprot.readBinary();
+ struct.attributes.put(_key407, _val408);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRows_result implements org.apache.thrift.TBase<mutateRows_result, mutateRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRows_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRows_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRows_result.class, metaDataMap);
+ }
+
+ public mutateRows_result() {
+ }
+
+ public mutateRows_result(
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRows_result(mutateRows_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public mutateRows_result deepCopy() {
+ return new mutateRows_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ this.ia = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public mutateRows_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public mutateRows_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRows_result)
+ return this.equals((mutateRows_result)that);
+ return false;
+ }
+
+ public boolean equals(mutateRows_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRows_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRows_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRows_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRows_resultStandardScheme getScheme() {
+ return new mutateRows_resultStandardScheme();
+ }
+ }
+
+ private static class mutateRows_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRows_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRows_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRows_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRows_resultTupleScheme getScheme() {
+ return new mutateRows_resultTupleScheme();
+ }
+ }
+
+ private static class mutateRows_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRows_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRowsTs_args implements org.apache.thrift.TBase<mutateRowsTs_args, mutateRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRowsTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRowsTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * list of row batches
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<BatchMutation> rowBatches; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Mutation attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * list of row batches
+ */
+ ROW_BATCHES((short)2, "rowBatches"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)3, "timestamp"),
+ /**
+ * Mutation attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW_BATCHES
+ return ROW_BATCHES;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowsTs_args.class, metaDataMap);
+ }
+
+ public mutateRowsTs_args() {
+ }
+
+ public mutateRowsTs_args(
+ java.nio.ByteBuffer tableName,
+ java.util.List<BatchMutation> rowBatches,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.rowBatches = rowBatches;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRowsTs_args(mutateRowsTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRowBatches()) {
+ java.util.List<BatchMutation> __this__rowBatches = new java.util.ArrayList<BatchMutation>(other.rowBatches.size());
+ for (BatchMutation other_element : other.rowBatches) {
+ __this__rowBatches.add(new BatchMutation(other_element));
+ }
+ this.rowBatches = __this__rowBatches;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public mutateRowsTs_args deepCopy() {
+ return new mutateRowsTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.rowBatches = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public mutateRowsTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public mutateRowsTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowBatchesSize() {
+ return (this.rowBatches == null) ? 0 : this.rowBatches.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
+ return (this.rowBatches == null) ? null : this.rowBatches.iterator();
+ }
+
+ public void addToRowBatches(BatchMutation elem) {
+ if (this.rowBatches == null) {
+ this.rowBatches = new java.util.ArrayList<BatchMutation>();
+ }
+ this.rowBatches.add(elem);
+ }
+
+ /**
+ * list of row batches
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<BatchMutation> getRowBatches() {
+ return this.rowBatches;
+ }
+
+ /**
+ * list of row batches
+ */
+ public mutateRowsTs_args setRowBatches(@org.apache.thrift.annotation.Nullable java.util.List<BatchMutation> rowBatches) {
+ this.rowBatches = rowBatches;
+ return this;
+ }
+
+ public void unsetRowBatches() {
+ this.rowBatches = null;
+ }
+
+ /** Returns true if field rowBatches is set (has been assigned a value) and false otherwise */
+ public boolean isSetRowBatches() {
+ return this.rowBatches != null;
+ }
+
+ public void setRowBatchesIsSet(boolean value) {
+ if (!value) {
+ this.rowBatches = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public mutateRowsTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Mutation attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Mutation attributes
+ */
+ public mutateRowsTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW_BATCHES:
+ if (value == null) {
+ unsetRowBatches();
+ } else {
+ setRowBatches((java.util.List<BatchMutation>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW_BATCHES:
+ return getRowBatches();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW_BATCHES:
+ return isSetRowBatches();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRowsTs_args)
+ return this.equals((mutateRowsTs_args)that);
+ return false;
+ }
+
+ public boolean equals(mutateRowsTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_rowBatches = true && this.isSetRowBatches();
+ boolean that_present_rowBatches = true && that.isSetRowBatches();
+ if (this_present_rowBatches || that_present_rowBatches) {
+ if (!(this_present_rowBatches && that_present_rowBatches))
+ return false;
+ if (!this.rowBatches.equals(that.rowBatches))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRowBatches()) ? 131071 : 524287);
+ if (isSetRowBatches())
+ hashCode = hashCode * 8191 + rowBatches.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRowsTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRowBatches(), other.isSetRowBatches());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRowBatches()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowBatches, other.rowBatches);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRowsTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("rowBatches:");
+ if (this.rowBatches == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.rowBatches);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRowsTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowsTs_argsStandardScheme getScheme() {
+ return new mutateRowsTs_argsStandardScheme();
+ }
+ }
+
+ private static class mutateRowsTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRowsTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRowsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW_BATCHES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list410 = iprot.readListBegin();
+ struct.rowBatches = new java.util.ArrayList<BatchMutation>(_list410.size);
+ @org.apache.thrift.annotation.Nullable BatchMutation _elem411;
+ for (int _i412 = 0; _i412 < _list410.size; ++_i412)
+ {
+ _elem411 = new BatchMutation();
+ _elem411.read(iprot);
+ struct.rowBatches.add(_elem411);
+ }
+ iprot.readListEnd();
+ }
+ struct.setRowBatchesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map413 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map413.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key414;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val415;
+ for (int _i416 = 0; _i416 < _map413.size; ++_i416)
+ {
+ _key414 = iprot.readBinary();
+ _val415 = iprot.readBinary();
+ struct.attributes.put(_key414, _val415);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRowsTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.rowBatches != null) {
+ oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.rowBatches.size()));
+ for (BatchMutation _iter417 : struct.rowBatches)
+ {
+ _iter417.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter418 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter418.getKey());
+ oprot.writeBinary(_iter418.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRowsTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowsTs_argsTupleScheme getScheme() {
+ return new mutateRowsTs_argsTupleScheme();
+ }
+ }
+
+ private static class mutateRowsTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRowsTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRowsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRowBatches()) {
+ optionals.set(1);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRowBatches()) {
+ {
+ oprot.writeI32(struct.rowBatches.size());
+ for (BatchMutation _iter419 : struct.rowBatches)
+ {
+ _iter419.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter420 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter420.getKey());
+ oprot.writeBinary(_iter420.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRowsTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TList _list421 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.rowBatches = new java.util.ArrayList<BatchMutation>(_list421.size);
+ @org.apache.thrift.annotation.Nullable BatchMutation _elem422;
+ for (int _i423 = 0; _i423 < _list421.size; ++_i423)
+ {
+ _elem422 = new BatchMutation();
+ _elem422.read(iprot);
+ struct.rowBatches.add(_elem422);
+ }
+ }
+ struct.setRowBatchesIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map424 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map424.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key425;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val426;
+ for (int _i427 = 0; _i427 < _map424.size; ++_i427)
+ {
+ _key425 = iprot.readBinary();
+ _val426 = iprot.readBinary();
+ struct.attributes.put(_key425, _val426);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRowsTs_result implements org.apache.thrift.TBase<mutateRowsTs_result, mutateRowsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRowsTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRowsTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRowsTs_result.class, metaDataMap);
+ }
+
+ public mutateRowsTs_result() {
+ }
+
+ public mutateRowsTs_result(
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRowsTs_result(mutateRowsTs_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public mutateRowsTs_result deepCopy() {
+ return new mutateRowsTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ this.ia = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public mutateRowsTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public mutateRowsTs_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRowsTs_result)
+ return this.equals((mutateRowsTs_result)that);
+ return false;
+ }
+
+ public boolean equals(mutateRowsTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRowsTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRowsTs_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRowsTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowsTs_resultStandardScheme getScheme() {
+ return new mutateRowsTs_resultStandardScheme();
+ }
+ }
+
+ private static class mutateRowsTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRowsTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRowsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRowsTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRowsTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRowsTs_resultTupleScheme getScheme() {
+ return new mutateRowsTs_resultTupleScheme();
+ }
+ }
+
+ private static class mutateRowsTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRowsTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRowsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRowsTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class atomicIncrement_args implements org.apache.thrift.TBase<atomicIncrement_args, atomicIncrement_args._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new atomicIncrement_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new atomicIncrement_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row to increment
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * name of column
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ /**
+ * amount to increment by
+ */
+ public long value; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row to increment
+ */
+ ROW((short)2, "row"),
+ /**
+ * name of column
+ */
+ COLUMN((short)3, "column"),
+ /**
+ * amount to increment by
+ */
+ VALUE((short)4, "value");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // VALUE
+ return VALUE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __VALUE_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(atomicIncrement_args.class, metaDataMap);
+ }
+
+ public atomicIncrement_args() {
+ }
+
+ public atomicIncrement_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ long value)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.value = value;
+ setValueIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public atomicIncrement_args(atomicIncrement_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ this.value = other.value;
+ }
+
+ public atomicIncrement_args deepCopy() {
+ return new atomicIncrement_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.column = null;
+ setValueIsSet(false);
+ this.value = 0;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public atomicIncrement_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public atomicIncrement_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row to increment
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row to increment
+ */
+ public atomicIncrement_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public atomicIncrement_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * name of column
+ */
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * name of column
+ */
+ public atomicIncrement_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public atomicIncrement_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ /**
+ * amount to increment by
+ */
+ public long getValue() {
+ return this.value;
+ }
+
+ /**
+ * amount to increment by
+ */
+ public atomicIncrement_args setValue(long value) {
+ this.value = value;
+ setValueIsSet(true);
+ return this;
+ }
+
+ public void unsetValue() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __VALUE_ISSET_ID);
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __VALUE_ISSET_ID);
+ }
+
+ public void setValueIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __VALUE_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ setValue((java.lang.Long)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case VALUE:
+ return getValue();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case VALUE:
+ return isSetValue();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof atomicIncrement_args)
+ return this.equals((atomicIncrement_args)that);
+ return false;
+ }
+
+ public boolean equals(atomicIncrement_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_value = true;
+ boolean that_present_value = true;
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (this.value != that.value)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(value);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(atomicIncrement_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("atomicIncrement_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("value:");
+ sb.append(this.value);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class atomicIncrement_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public atomicIncrement_argsStandardScheme getScheme() {
+ return new atomicIncrement_argsStandardScheme();
+ }
+ }
+
+ private static class atomicIncrement_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<atomicIncrement_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, atomicIncrement_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.value = iprot.readI64();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, atomicIncrement_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeI64(struct.value);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class atomicIncrement_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public atomicIncrement_argsTupleScheme getScheme() {
+ return new atomicIncrement_argsTupleScheme();
+ }
+ }
+
+ private static class atomicIncrement_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<atomicIncrement_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, atomicIncrement_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetValue()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetValue()) {
+ oprot.writeI64(struct.value);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, atomicIncrement_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.value = iprot.readI64();
+ struct.setValueIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class atomicIncrement_result implements org.apache.thrift.TBase<atomicIncrement_result, atomicIncrement_result._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new atomicIncrement_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new atomicIncrement_resultTupleSchemeFactory();
+
+ public long success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(atomicIncrement_result.class, metaDataMap);
+ }
+
+ public atomicIncrement_result() {
+ }
+
+ public atomicIncrement_result(
+ long success,
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public atomicIncrement_result(atomicIncrement_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public atomicIncrement_result deepCopy() {
+ return new atomicIncrement_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ this.ia = null;
+ }
+
+ public long getSuccess() {
+ return this.success;
+ }
+
+ public atomicIncrement_result setSuccess(long success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public atomicIncrement_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public atomicIncrement_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Long)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof atomicIncrement_result)
+ return this.equals((atomicIncrement_result)that);
+ return false;
+ }
+
+ public boolean equals(atomicIncrement_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(success);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(atomicIncrement_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("atomicIncrement_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class atomicIncrement_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public atomicIncrement_resultStandardScheme getScheme() {
+ return new atomicIncrement_resultStandardScheme();
+ }
+ }
+
+ private static class atomicIncrement_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<atomicIncrement_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, atomicIncrement_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.success = iprot.readI64();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, atomicIncrement_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI64(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class atomicIncrement_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public atomicIncrement_resultTupleScheme getScheme() {
+ return new atomicIncrement_resultTupleScheme();
+ }
+ }
+
+ private static class atomicIncrement_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<atomicIncrement_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, atomicIncrement_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetSuccess()) {
+ oprot.writeI64(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, atomicIncrement_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI64();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAll_args implements org.apache.thrift.TBase<deleteAll_args, deleteAll_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAll_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAll_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * Row to update
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * name of column whose value is to be deleted
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ /**
+ * Delete attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * Row to update
+ */
+ ROW((short)2, "row"),
+ /**
+ * name of column whose value is to be deleted
+ */
+ COLUMN((short)3, "column"),
+ /**
+ * Delete attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAll_args.class, metaDataMap);
+ }
+
+ public deleteAll_args() {
+ }
+
+ public deleteAll_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAll_args(deleteAll_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public deleteAll_args deepCopy() {
+ return new deleteAll_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.column = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public deleteAll_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public deleteAll_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * Row to update
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * Row to update
+ */
+ public deleteAll_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public deleteAll_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * 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();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * name of column whose value is to be deleted
+ */
+ public deleteAll_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public deleteAll_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Delete attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Delete attributes
+ */
+ public deleteAll_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAll_args)
+ return this.equals((deleteAll_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteAll_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAll_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAll_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAll_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAll_argsStandardScheme getScheme() {
+ return new deleteAll_argsStandardScheme();
+ }
+ }
+
+ private static class deleteAll_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAll_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAll_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map428 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map428.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key429;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val430;
+ for (int _i431 = 0; _i431 < _map428.size; ++_i431)
+ {
+ _key429 = iprot.readBinary();
+ _val430 = iprot.readBinary();
+ struct.attributes.put(_key429, _val430);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAll_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter432 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter432.getKey());
+ oprot.writeBinary(_iter432.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAll_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAll_argsTupleScheme getScheme() {
+ return new deleteAll_argsTupleScheme();
+ }
+ }
+
+ private static class deleteAll_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAll_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAll_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter433 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter433.getKey());
+ oprot.writeBinary(_iter433.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAll_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map434 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map434.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key435;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val436;
+ for (int _i437 = 0; _i437 < _map434.size; ++_i437)
+ {
+ _key435 = iprot.readBinary();
+ _val436 = iprot.readBinary();
+ struct.attributes.put(_key435, _val436);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAll_result implements org.apache.thrift.TBase<deleteAll_result, deleteAll_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAll_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAll_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAll_result.class, metaDataMap);
+ }
+
+ public deleteAll_result() {
+ }
+
+ public deleteAll_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAll_result(deleteAll_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public deleteAll_result deepCopy() {
+ return new deleteAll_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public deleteAll_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAll_result)
+ return this.equals((deleteAll_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteAll_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAll_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAll_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAll_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAll_resultStandardScheme getScheme() {
+ return new deleteAll_resultStandardScheme();
+ }
+ }
+
+ private static class deleteAll_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAll_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAll_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAll_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAll_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAll_resultTupleScheme getScheme() {
+ return new deleteAll_resultTupleScheme();
+ }
+ }
+
+ private static class deleteAll_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAll_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAll_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAll_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAllTs_args implements org.apache.thrift.TBase<deleteAllTs_args, deleteAllTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAllTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAllTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * Row to update
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * name of column whose value is to be deleted
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Delete attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * Row to update
+ */
+ ROW((short)2, "row"),
+ /**
+ * name of column whose value is to be deleted
+ */
+ COLUMN((short)3, "column"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)4, "timestamp"),
+ /**
+ * Delete attributes
+ */
+ ATTRIBUTES((short)5, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllTs_args.class, metaDataMap);
+ }
+
+ public deleteAllTs_args() {
+ }
+
+ public deleteAllTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAllTs_args(deleteAllTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public deleteAllTs_args deepCopy() {
+ return new deleteAllTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.column = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public deleteAllTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public deleteAllTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * Row to update
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * Row to update
+ */
+ public deleteAllTs_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public deleteAllTs_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * 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();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * name of column whose value is to be deleted
+ */
+ public deleteAllTs_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public deleteAllTs_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public deleteAllTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Delete attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Delete attributes
+ */
+ public deleteAllTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAllTs_args)
+ return this.equals((deleteAllTs_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteAllTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAllTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAllTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAllTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllTs_argsStandardScheme getScheme() {
+ return new deleteAllTs_argsStandardScheme();
+ }
+ }
+
+ private static class deleteAllTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAllTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAllTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map438 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map438.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key439;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val440;
+ for (int _i441 = 0; _i441 < _map438.size; ++_i441)
+ {
+ _key439 = iprot.readBinary();
+ _val440 = iprot.readBinary();
+ struct.attributes.put(_key439, _val440);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAllTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter442 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter442.getKey());
+ oprot.writeBinary(_iter442.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAllTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllTs_argsTupleScheme getScheme() {
+ return new deleteAllTs_argsTupleScheme();
+ }
+ }
+
+ private static class deleteAllTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAllTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAllTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(3);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter443 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter443.getKey());
+ oprot.writeBinary(_iter443.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAllTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(4)) {
+ {
+ org.apache.thrift.protocol.TMap _map444 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map444.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key445;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val446;
+ for (int _i447 = 0; _i447 < _map444.size; ++_i447)
+ {
+ _key445 = iprot.readBinary();
+ _val446 = iprot.readBinary();
+ struct.attributes.put(_key445, _val446);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAllTs_result implements org.apache.thrift.TBase<deleteAllTs_result, deleteAllTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAllTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAllTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllTs_result.class, metaDataMap);
+ }
+
+ public deleteAllTs_result() {
+ }
+
+ public deleteAllTs_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAllTs_result(deleteAllTs_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public deleteAllTs_result deepCopy() {
+ return new deleteAllTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public deleteAllTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAllTs_result)
+ return this.equals((deleteAllTs_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteAllTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAllTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAllTs_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAllTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllTs_resultStandardScheme getScheme() {
+ return new deleteAllTs_resultStandardScheme();
+ }
+ }
+
+ private static class deleteAllTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAllTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAllTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAllTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAllTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllTs_resultTupleScheme getScheme() {
+ return new deleteAllTs_resultTupleScheme();
+ }
+ }
+
+ private static class deleteAllTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAllTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAllTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAllTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAllRow_args implements org.apache.thrift.TBase<deleteAllRow_args, deleteAllRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAllRow_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAllRow_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * key of the row to be completely deleted.
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * Delete attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * key of the row to be completely deleted.
+ */
+ ROW((short)2, "row"),
+ /**
+ * Delete attributes
+ */
+ ATTRIBUTES((short)3, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRow_args.class, metaDataMap);
+ }
+
+ public deleteAllRow_args() {
+ }
+
+ public deleteAllRow_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAllRow_args(deleteAllRow_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public deleteAllRow_args deepCopy() {
+ return new deleteAllRow_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public deleteAllRow_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public deleteAllRow_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * key of the row to be completely deleted.
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * key of the row to be completely deleted.
+ */
+ public deleteAllRow_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public deleteAllRow_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Delete attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Delete attributes
+ */
+ public deleteAllRow_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAllRow_args)
+ return this.equals((deleteAllRow_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteAllRow_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAllRow_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAllRow_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAllRow_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRow_argsStandardScheme getScheme() {
+ return new deleteAllRow_argsStandardScheme();
+ }
+ }
+
+ private static class deleteAllRow_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAllRow_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAllRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map448 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map448.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key449;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val450;
+ for (int _i451 = 0; _i451 < _map448.size; ++_i451)
+ {
+ _key449 = iprot.readBinary();
+ _val450 = iprot.readBinary();
+ struct.attributes.put(_key449, _val450);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAllRow_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter452 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter452.getKey());
+ oprot.writeBinary(_iter452.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAllRow_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRow_argsTupleScheme getScheme() {
+ return new deleteAllRow_argsTupleScheme();
+ }
+ }
+
+ private static class deleteAllRow_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAllRow_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAllRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter453 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter453.getKey());
+ oprot.writeBinary(_iter453.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAllRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TMap _map454 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map454.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key455;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val456;
+ for (int _i457 = 0; _i457 < _map454.size; ++_i457)
+ {
+ _key455 = iprot.readBinary();
+ _val456 = iprot.readBinary();
+ struct.attributes.put(_key455, _val456);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAllRow_result implements org.apache.thrift.TBase<deleteAllRow_result, deleteAllRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAllRow_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAllRow_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRow_result.class, metaDataMap);
+ }
+
+ public deleteAllRow_result() {
+ }
+
+ public deleteAllRow_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAllRow_result(deleteAllRow_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public deleteAllRow_result deepCopy() {
+ return new deleteAllRow_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public deleteAllRow_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAllRow_result)
+ return this.equals((deleteAllRow_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteAllRow_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAllRow_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAllRow_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAllRow_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRow_resultStandardScheme getScheme() {
+ return new deleteAllRow_resultStandardScheme();
+ }
+ }
+
+ private static class deleteAllRow_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAllRow_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAllRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAllRow_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAllRow_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRow_resultTupleScheme getScheme() {
+ return new deleteAllRow_resultTupleScheme();
+ }
+ }
+
+ private static class deleteAllRow_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAllRow_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAllRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAllRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class increment_args implements org.apache.thrift.TBase<increment_args, increment_args._Fields>, java.io.Serializable, Cloneable, Comparable<increment_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_args");
+
+ private static final org.apache.thrift.protocol.TField INCREMENT_FIELD_DESC = new org.apache.thrift.protocol.TField("increment", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new increment_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new increment_argsTupleSchemeFactory();
+
+ /**
+ * The single increment to apply
+ */
+ public @org.apache.thrift.annotation.Nullable TIncrement increment; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * The single increment to apply
+ */
+ INCREMENT((short)1, "increment");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // INCREMENT
+ return INCREMENT;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.INCREMENT, new org.apache.thrift.meta_data.FieldMetaData("increment", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIncrement.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_args.class, metaDataMap);
+ }
+
+ public increment_args() {
+ }
+
+ public increment_args(
+ TIncrement increment)
+ {
+ this();
+ this.increment = increment;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public increment_args(increment_args other) {
+ if (other.isSetIncrement()) {
+ this.increment = new TIncrement(other.increment);
+ }
+ }
+
+ public increment_args deepCopy() {
+ return new increment_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.increment = null;
+ }
+
+ /**
+ * The single increment to apply
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TIncrement getIncrement() {
+ return this.increment;
+ }
+
+ /**
+ * The single increment to apply
+ */
+ public increment_args setIncrement(@org.apache.thrift.annotation.Nullable TIncrement increment) {
+ this.increment = increment;
+ return this;
+ }
+
+ public void unsetIncrement() {
+ this.increment = null;
+ }
+
+ /** Returns true if field increment is set (has been assigned a value) and false otherwise */
+ public boolean isSetIncrement() {
+ return this.increment != null;
+ }
+
+ public void setIncrementIsSet(boolean value) {
+ if (!value) {
+ this.increment = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case INCREMENT:
+ if (value == null) {
+ unsetIncrement();
+ } else {
+ setIncrement((TIncrement)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case INCREMENT:
+ return getIncrement();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case INCREMENT:
+ return isSetIncrement();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof increment_args)
+ return this.equals((increment_args)that);
+ return false;
+ }
+
+ public boolean equals(increment_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_increment = true && this.isSetIncrement();
+ boolean that_present_increment = true && that.isSetIncrement();
+ if (this_present_increment || that_present_increment) {
+ if (!(this_present_increment && that_present_increment))
+ return false;
+ if (!this.increment.equals(that.increment))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIncrement()) ? 131071 : 524287);
+ if (isSetIncrement())
+ hashCode = hashCode * 8191 + increment.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(increment_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIncrement(), other.isSetIncrement());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIncrement()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.increment, other.increment);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("increment_args(");
+ boolean first = true;
+
+ sb.append("increment:");
+ if (this.increment == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.increment);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (increment != null) {
+ increment.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class increment_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_argsStandardScheme getScheme() {
+ return new increment_argsStandardScheme();
+ }
+ }
+
+ private static class increment_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<increment_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, increment_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // INCREMENT
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.increment = new TIncrement();
+ struct.increment.read(iprot);
+ struct.setIncrementIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, increment_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.increment != null) {
+ oprot.writeFieldBegin(INCREMENT_FIELD_DESC);
+ struct.increment.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class increment_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_argsTupleScheme getScheme() {
+ return new increment_argsTupleScheme();
+ }
+ }
+
+ private static class increment_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<increment_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIncrement()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIncrement()) {
+ struct.increment.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.increment = new TIncrement();
+ struct.increment.read(iprot);
+ struct.setIncrementIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class increment_result implements org.apache.thrift.TBase<increment_result, increment_result._Fields>, java.io.Serializable, Cloneable, Comparable<increment_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new increment_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new increment_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_result.class, metaDataMap);
+ }
+
+ public increment_result() {
+ }
+
+ public increment_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public increment_result(increment_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public increment_result deepCopy() {
+ return new increment_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public increment_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof increment_result)
+ return this.equals((increment_result)that);
+ return false;
+ }
+
+ public boolean equals(increment_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(increment_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("increment_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class increment_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_resultStandardScheme getScheme() {
+ return new increment_resultStandardScheme();
+ }
+ }
+
+ private static class increment_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<increment_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, increment_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, increment_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class increment_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_resultTupleScheme getScheme() {
+ return new increment_resultTupleScheme();
+ }
+ }
+
+ private static class increment_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<increment_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class incrementRows_args implements org.apache.thrift.TBase<incrementRows_args, incrementRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<incrementRows_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("incrementRows_args");
+
+ private static final org.apache.thrift.protocol.TField INCREMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("increments", org.apache.thrift.protocol.TType.LIST, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new incrementRows_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new incrementRows_argsTupleSchemeFactory();
+
+ /**
+ * The list of increments
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<TIncrement> increments; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * The list of increments
+ */
+ INCREMENTS((short)1, "increments");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // INCREMENTS
+ return INCREMENTS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.INCREMENTS, new org.apache.thrift.meta_data.FieldMetaData("increments", 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, TIncrement.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(incrementRows_args.class, metaDataMap);
+ }
+
+ public incrementRows_args() {
+ }
+
+ public incrementRows_args(
+ java.util.List<TIncrement> increments)
+ {
+ this();
+ this.increments = increments;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public incrementRows_args(incrementRows_args other) {
+ if (other.isSetIncrements()) {
+ java.util.List<TIncrement> __this__increments = new java.util.ArrayList<TIncrement>(other.increments.size());
+ for (TIncrement other_element : other.increments) {
+ __this__increments.add(new TIncrement(other_element));
+ }
+ this.increments = __this__increments;
+ }
+ }
+
+ public incrementRows_args deepCopy() {
+ return new incrementRows_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.increments = null;
+ }
+
+ public int getIncrementsSize() {
+ return (this.increments == null) ? 0 : this.increments.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TIncrement> getIncrementsIterator() {
+ return (this.increments == null) ? null : this.increments.iterator();
+ }
+
+ public void addToIncrements(TIncrement elem) {
+ if (this.increments == null) {
+ this.increments = new java.util.ArrayList<TIncrement>();
+ }
+ this.increments.add(elem);
+ }
+
+ /**
+ * The list of increments
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TIncrement> getIncrements() {
+ return this.increments;
+ }
+
+ /**
+ * The list of increments
+ */
+ public incrementRows_args setIncrements(@org.apache.thrift.annotation.Nullable java.util.List<TIncrement> increments) {
+ this.increments = increments;
+ return this;
+ }
+
+ public void unsetIncrements() {
+ this.increments = null;
+ }
+
+ /** Returns true if field increments is set (has been assigned a value) and false otherwise */
+ public boolean isSetIncrements() {
+ return this.increments != null;
+ }
+
+ public void setIncrementsIsSet(boolean value) {
+ if (!value) {
+ this.increments = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case INCREMENTS:
+ if (value == null) {
+ unsetIncrements();
+ } else {
+ setIncrements((java.util.List<TIncrement>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case INCREMENTS:
+ return getIncrements();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case INCREMENTS:
+ return isSetIncrements();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof incrementRows_args)
+ return this.equals((incrementRows_args)that);
+ return false;
+ }
+
+ public boolean equals(incrementRows_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_increments = true && this.isSetIncrements();
+ boolean that_present_increments = true && that.isSetIncrements();
+ if (this_present_increments || that_present_increments) {
+ if (!(this_present_increments && that_present_increments))
+ return false;
+ if (!this.increments.equals(that.increments))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIncrements()) ? 131071 : 524287);
+ if (isSetIncrements())
+ hashCode = hashCode * 8191 + increments.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(incrementRows_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIncrements(), other.isSetIncrements());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIncrements()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.increments, other.increments);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("incrementRows_args(");
+ boolean first = true;
+
+ sb.append("increments:");
+ if (this.increments == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.increments);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class incrementRows_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public incrementRows_argsStandardScheme getScheme() {
+ return new incrementRows_argsStandardScheme();
+ }
+ }
+
+ private static class incrementRows_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<incrementRows_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, incrementRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // INCREMENTS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list458 = iprot.readListBegin();
+ struct.increments = new java.util.ArrayList<TIncrement>(_list458.size);
+ @org.apache.thrift.annotation.Nullable TIncrement _elem459;
+ for (int _i460 = 0; _i460 < _list458.size; ++_i460)
+ {
+ _elem459 = new TIncrement();
+ _elem459.read(iprot);
+ struct.increments.add(_elem459);
+ }
+ iprot.readListEnd();
+ }
+ struct.setIncrementsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, incrementRows_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.increments != null) {
+ oprot.writeFieldBegin(INCREMENTS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.increments.size()));
+ for (TIncrement _iter461 : struct.increments)
+ {
+ _iter461.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class incrementRows_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public incrementRows_argsTupleScheme getScheme() {
+ return new incrementRows_argsTupleScheme();
+ }
+ }
+
+ private static class incrementRows_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<incrementRows_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, incrementRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIncrements()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIncrements()) {
+ {
+ oprot.writeI32(struct.increments.size());
+ for (TIncrement _iter462 : struct.increments)
+ {
+ _iter462.write(oprot);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, incrementRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list463 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.increments = new java.util.ArrayList<TIncrement>(_list463.size);
+ @org.apache.thrift.annotation.Nullable TIncrement _elem464;
+ for (int _i465 = 0; _i465 < _list463.size; ++_i465)
+ {
+ _elem464 = new TIncrement();
+ _elem464.read(iprot);
+ struct.increments.add(_elem464);
+ }
+ }
+ struct.setIncrementsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class incrementRows_result implements org.apache.thrift.TBase<incrementRows_result, incrementRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<incrementRows_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("incrementRows_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new incrementRows_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new incrementRows_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(incrementRows_result.class, metaDataMap);
+ }
+
+ public incrementRows_result() {
+ }
+
+ public incrementRows_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public incrementRows_result(incrementRows_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public incrementRows_result deepCopy() {
+ return new incrementRows_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public incrementRows_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof incrementRows_result)
+ return this.equals((incrementRows_result)that);
+ return false;
+ }
+
+ public boolean equals(incrementRows_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(incrementRows_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("incrementRows_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class incrementRows_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public incrementRows_resultStandardScheme getScheme() {
+ return new incrementRows_resultStandardScheme();
+ }
+ }
+
+ private static class incrementRows_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<incrementRows_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, incrementRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, incrementRows_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class incrementRows_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public incrementRows_resultTupleScheme getScheme() {
+ return new incrementRows_resultTupleScheme();
+ }
+ }
+
+ private static class incrementRows_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<incrementRows_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, incrementRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, incrementRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAllRowTs_args implements org.apache.thrift.TBase<deleteAllRowTs_args, deleteAllRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAllRowTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAllRowTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * key of the row to be completely deleted.
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Delete attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * key of the row to be completely deleted.
+ */
+ ROW((short)2, "row"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)3, "timestamp"),
+ /**
+ * Delete attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRowTs_args.class, metaDataMap);
+ }
+
+ public deleteAllRowTs_args() {
+ }
+
+ public deleteAllRowTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAllRowTs_args(deleteAllRowTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public deleteAllRowTs_args deepCopy() {
+ return new deleteAllRowTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public deleteAllRowTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public deleteAllRowTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * key of the row to be completely deleted.
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * key of the row to be completely deleted.
+ */
+ public deleteAllRowTs_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public deleteAllRowTs_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public deleteAllRowTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Delete attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Delete attributes
+ */
+ public deleteAllRowTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAllRowTs_args)
+ return this.equals((deleteAllRowTs_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteAllRowTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAllRowTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAllRowTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAllRowTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRowTs_argsStandardScheme getScheme() {
+ return new deleteAllRowTs_argsStandardScheme();
+ }
+ }
+
+ private static class deleteAllRowTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAllRowTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAllRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map466 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map466.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key467;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val468;
+ for (int _i469 = 0; _i469 < _map466.size; ++_i469)
+ {
+ _key467 = iprot.readBinary();
+ _val468 = iprot.readBinary();
+ struct.attributes.put(_key467, _val468);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAllRowTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter470 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter470.getKey());
+ oprot.writeBinary(_iter470.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAllRowTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRowTs_argsTupleScheme getScheme() {
+ return new deleteAllRowTs_argsTupleScheme();
+ }
+ }
+
+ private static class deleteAllRowTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAllRowTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAllRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter471 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter471.getKey());
+ oprot.writeBinary(_iter471.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAllRowTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map472 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map472.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key473;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val474;
+ for (int _i475 = 0; _i475 < _map472.size; ++_i475)
+ {
+ _key473 = iprot.readBinary();
+ _val474 = iprot.readBinary();
+ struct.attributes.put(_key473, _val474);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteAllRowTs_result implements org.apache.thrift.TBase<deleteAllRowTs_result, deleteAllRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteAllRowTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteAllRowTs_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteAllRowTs_result.class, metaDataMap);
+ }
+
+ public deleteAllRowTs_result() {
+ }
+
+ public deleteAllRowTs_result(
+ IOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteAllRowTs_result(deleteAllRowTs_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public deleteAllRowTs_result deepCopy() {
+ return new deleteAllRowTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public deleteAllRowTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteAllRowTs_result)
+ return this.equals((deleteAllRowTs_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteAllRowTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteAllRowTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteAllRowTs_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteAllRowTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRowTs_resultStandardScheme getScheme() {
+ return new deleteAllRowTs_resultStandardScheme();
+ }
+ }
+
+ private static class deleteAllRowTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteAllRowTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteAllRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteAllRowTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteAllRowTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteAllRowTs_resultTupleScheme getScheme() {
+ return new deleteAllRowTs_resultTupleScheme();
+ }
+ }
+
+ private static class deleteAllRowTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteAllRowTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteAllRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteAllRowTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithScan_args implements org.apache.thrift.TBase<scannerOpenWithScan_args, scannerOpenWithScan_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithScan_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithScan_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithScan_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * Scan instance
+ */
+ public @org.apache.thrift.annotation.Nullable TScan scan; // required
+ /**
+ * Scan attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * Scan instance
+ */
+ SCAN((short)2, "scan"),
+ /**
+ * Scan attributes
+ */
+ ATTRIBUTES((short)3, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // SCAN
+ return SCAN;
+ case 3: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithScan_args.class, metaDataMap);
+ }
+
+ public scannerOpenWithScan_args() {
+ }
+
+ public scannerOpenWithScan_args(
+ java.nio.ByteBuffer tableName,
+ TScan scan,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.scan = scan;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithScan_args(scannerOpenWithScan_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetScan()) {
+ this.scan = new TScan(other.scan);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public scannerOpenWithScan_args deepCopy() {
+ return new scannerOpenWithScan_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.scan = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public scannerOpenWithScan_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public scannerOpenWithScan_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * Scan instance
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TScan getScan() {
+ return this.scan;
+ }
+
+ /**
+ * Scan instance
+ */
+ public scannerOpenWithScan_args setScan(@org.apache.thrift.annotation.Nullable TScan scan) {
+ this.scan = scan;
+ return this;
+ }
+
+ public void unsetScan() {
+ this.scan = null;
+ }
+
+ /** Returns true if field scan is set (has been assigned a value) and false otherwise */
+ public boolean isSetScan() {
+ return this.scan != null;
+ }
+
+ public void setScanIsSet(boolean value) {
+ if (!value) {
+ this.scan = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Scan attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Scan attributes
+ */
+ public scannerOpenWithScan_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case SCAN:
+ if (value == null) {
+ unsetScan();
+ } else {
+ setScan((TScan)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case SCAN:
+ return getScan();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case SCAN:
+ return isSetScan();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithScan_args)
+ return this.equals((scannerOpenWithScan_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithScan_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_scan = true && this.isSetScan();
+ boolean that_present_scan = true && that.isSetScan();
+ if (this_present_scan || that_present_scan) {
+ if (!(this_present_scan && that_present_scan))
+ return false;
+ if (!this.scan.equals(that.scan))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetScan()) ? 131071 : 524287);
+ if (isSetScan())
+ hashCode = hashCode * 8191 + scan.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithScan_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetScan(), other.isSetScan());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetScan()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, other.scan);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithScan_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("scan:");
+ if (this.scan == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.scan);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (scan != null) {
+ scan.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithScan_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithScan_argsStandardScheme getScheme() {
+ return new scannerOpenWithScan_argsStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithScan_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithScan_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithScan_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // SCAN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.scan = new TScan();
+ struct.scan.read(iprot);
+ struct.setScanIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map476 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map476.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key477;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val478;
+ for (int _i479 = 0; _i479 < _map476.size; ++_i479)
+ {
+ _key477 = iprot.readBinary();
+ _val478 = iprot.readBinary();
+ struct.attributes.put(_key477, _val478);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithScan_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.scan != null) {
+ oprot.writeFieldBegin(SCAN_FIELD_DESC);
+ struct.scan.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter480 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter480.getKey());
+ oprot.writeBinary(_iter480.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithScan_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithScan_argsTupleScheme getScheme() {
+ return new scannerOpenWithScan_argsTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithScan_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithScan_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithScan_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetScan()) {
+ optionals.set(1);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetScan()) {
+ struct.scan.write(oprot);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter481 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter481.getKey());
+ oprot.writeBinary(_iter481.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithScan_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.scan = new TScan();
+ struct.scan.read(iprot);
+ struct.setScanIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TMap _map482 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map482.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key483;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val484;
+ for (int _i485 = 0; _i485 < _map482.size; ++_i485)
+ {
+ _key483 = iprot.readBinary();
+ _val484 = iprot.readBinary();
+ struct.attributes.put(_key483, _val484);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithScan_result implements org.apache.thrift.TBase<scannerOpenWithScan_result, scannerOpenWithScan_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithScan_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithScan_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithScan_resultTupleSchemeFactory();
+
+ public int success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithScan_result.class, metaDataMap);
+ }
+
+ public scannerOpenWithScan_result() {
+ }
+
+ public scannerOpenWithScan_result(
+ int success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithScan_result(scannerOpenWithScan_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public scannerOpenWithScan_result deepCopy() {
+ return new scannerOpenWithScan_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ }
+
+ public int getSuccess() {
+ return this.success;
+ }
+
+ public scannerOpenWithScan_result setSuccess(int success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerOpenWithScan_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Integer)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithScan_result)
+ return this.equals((scannerOpenWithScan_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithScan_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + success;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithScan_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithScan_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithScan_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithScan_resultStandardScheme getScheme() {
+ return new scannerOpenWithScan_resultStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithScan_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithScan_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithScan_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithScan_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithScan_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithScan_resultTupleScheme getScheme() {
+ return new scannerOpenWithScan_resultTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithScan_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithScan_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithScan_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithScan_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpen_args implements org.apache.thrift.TBase<scannerOpen_args, scannerOpen_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpen_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpen_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow; // required
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ /**
+ * Scan attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ START_ROW((short)2, "startRow"),
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ COLUMNS((short)3, "columns"),
+ /**
+ * Scan attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // START_ROW
+ return START_ROW;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpen_args.class, metaDataMap);
+ }
+
+ public scannerOpen_args() {
+ }
+
+ public scannerOpen_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer startRow,
+ java.util.List<java.nio.ByteBuffer> columns,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpen_args(scannerOpen_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetStartRow()) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public scannerOpen_args deepCopy() {
+ return new scannerOpen_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.startRow = null;
+ this.columns = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public scannerOpen_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public scannerOpen_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * Starting row in table to scan.
+ * 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();
+ }
+
+ public java.nio.ByteBuffer bufferForStartRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ }
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public scannerOpen_args setStartRow(byte[] startRow) {
+ this.startRow = startRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startRow.clone());
+ return this;
+ }
+
+ public scannerOpen_args setStartRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ return this;
+ }
+
+ public void unsetStartRow() {
+ this.startRow = null;
+ }
+
+ /** Returns true if field startRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartRow() {
+ return this.startRow != null;
+ }
+
+ public void setStartRowIsSet(boolean value) {
+ if (!value) {
+ this.startRow = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public scannerOpen_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Scan attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Scan attributes
+ */
+ public scannerOpen_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case START_ROW:
+ if (value == null) {
+ unsetStartRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStartRow((byte[])value);
+ } else {
+ setStartRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case START_ROW:
+ return getStartRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case START_ROW:
+ return isSetStartRow();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpen_args)
+ return this.equals((scannerOpen_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpen_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_startRow = true && this.isSetStartRow();
+ boolean that_present_startRow = true && that.isSetStartRow();
+ if (this_present_startRow || that_present_startRow) {
+ if (!(this_present_startRow && that_present_startRow))
+ return false;
+ if (!this.startRow.equals(that.startRow))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStartRow()) ? 131071 : 524287);
+ if (isSetStartRow())
+ hashCode = hashCode * 8191 + startRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpen_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStartRow(), other.isSetStartRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, other.startRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpen_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("startRow:");
+ if (this.startRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpen_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpen_argsStandardScheme getScheme() {
+ return new scannerOpen_argsStandardScheme();
+ }
+ }
+
+ private static class scannerOpen_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpen_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpen_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // START_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list486 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list486.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem487;
+ for (int _i488 = 0; _i488 < _list486.size; ++_i488)
+ {
+ _elem487 = iprot.readBinary();
+ struct.columns.add(_elem487);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map489 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map489.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key490;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val491;
+ for (int _i492 = 0; _i492 < _map489.size; ++_i492)
+ {
+ _key490 = iprot.readBinary();
+ _val491 = iprot.readBinary();
+ struct.attributes.put(_key490, _val491);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpen_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.startRow != null) {
+ oprot.writeFieldBegin(START_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.startRow);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter493 : struct.columns)
+ {
+ oprot.writeBinary(_iter493);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter494 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter494.getKey());
+ oprot.writeBinary(_iter494.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpen_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpen_argsTupleScheme getScheme() {
+ return new scannerOpen_argsTupleScheme();
+ }
+ }
+
+ private static class scannerOpen_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpen_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpen_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStartRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetStartRow()) {
+ oprot.writeBinary(struct.startRow);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter495 : struct.columns)
+ {
+ oprot.writeBinary(_iter495);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter496 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter496.getKey());
+ oprot.writeBinary(_iter496.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpen_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list497 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list497.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem498;
+ for (int _i499 = 0; _i499 < _list497.size; ++_i499)
+ {
+ _elem498 = iprot.readBinary();
+ struct.columns.add(_elem498);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map500 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map500.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key501;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val502;
+ for (int _i503 = 0; _i503 < _map500.size; ++_i503)
+ {
+ _key501 = iprot.readBinary();
+ _val502 = iprot.readBinary();
+ struct.attributes.put(_key501, _val502);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpen_result implements org.apache.thrift.TBase<scannerOpen_result, scannerOpen_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpen_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpen_resultTupleSchemeFactory();
+
+ public int success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpen_result.class, metaDataMap);
+ }
+
+ public scannerOpen_result() {
+ }
+
+ public scannerOpen_result(
+ int success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpen_result(scannerOpen_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public scannerOpen_result deepCopy() {
+ return new scannerOpen_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ }
+
+ public int getSuccess() {
+ return this.success;
+ }
+
+ public scannerOpen_result setSuccess(int success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerOpen_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Integer)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpen_result)
+ return this.equals((scannerOpen_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpen_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + success;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpen_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpen_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpen_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpen_resultStandardScheme getScheme() {
+ return new scannerOpen_resultStandardScheme();
+ }
+ }
+
+ private static class scannerOpen_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpen_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpen_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpen_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpen_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpen_resultTupleScheme getScheme() {
+ return new scannerOpen_resultTupleScheme();
+ }
+ }
+
+ private static class scannerOpen_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpen_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpen_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpen_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithStop_args implements org.apache.thrift.TBase<scannerOpenWithStop_args, scannerOpenWithStop_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithStop_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithStop_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow; // required
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow; // required
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ /**
+ * Scan attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ START_ROW((short)2, "startRow"),
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ STOP_ROW((short)3, "stopRow"),
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ COLUMNS((short)4, "columns"),
+ /**
+ * Scan attributes
+ */
+ ATTRIBUTES((short)5, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // START_ROW
+ return START_ROW;
+ case 3: // STOP_ROW
+ return STOP_ROW;
+ case 4: // COLUMNS
+ return COLUMNS;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_args.class, metaDataMap);
+ }
+
+ public scannerOpenWithStop_args() {
+ }
+
+ public scannerOpenWithStop_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer startRow,
+ java.nio.ByteBuffer stopRow,
+ java.util.List<java.nio.ByteBuffer> columns,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithStop_args(scannerOpenWithStop_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetStartRow()) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
+ }
+ if (other.isSetStopRow()) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(other.stopRow);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public scannerOpenWithStop_args deepCopy() {
+ return new scannerOpenWithStop_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.startRow = null;
+ this.stopRow = null;
+ this.columns = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public scannerOpenWithStop_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public scannerOpenWithStop_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * Starting row in table to scan.
+ * 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();
+ }
+
+ public java.nio.ByteBuffer bufferForStartRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ }
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public scannerOpenWithStop_args setStartRow(byte[] startRow) {
+ this.startRow = startRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startRow.clone());
+ return this;
+ }
+
+ public scannerOpenWithStop_args setStartRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ return this;
+ }
+
+ public void unsetStartRow() {
+ this.startRow = null;
+ }
+
+ /** Returns true if field startRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartRow() {
+ return this.startRow != null;
+ }
+
+ public void setStartRowIsSet(boolean value) {
+ if (!value) {
+ this.startRow = null;
+ }
+ }
+
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ public byte[] getStopRow() {
+ setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow));
+ return stopRow == null ? null : stopRow.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStopRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ }
+
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ public scannerOpenWithStop_args setStopRow(byte[] stopRow) {
+ this.stopRow = stopRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(stopRow.clone());
+ return this;
+ }
+
+ public scannerOpenWithStop_args setStopRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ return this;
+ }
+
+ public void unsetStopRow() {
+ this.stopRow = null;
+ }
+
+ /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStopRow() {
+ return this.stopRow != null;
+ }
+
+ public void setStopRowIsSet(boolean value) {
+ if (!value) {
+ this.stopRow = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public scannerOpenWithStop_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Scan attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Scan attributes
+ */
+ public scannerOpenWithStop_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case START_ROW:
+ if (value == null) {
+ unsetStartRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStartRow((byte[])value);
+ } else {
+ setStartRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case STOP_ROW:
+ if (value == null) {
+ unsetStopRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStopRow((byte[])value);
+ } else {
+ setStopRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case START_ROW:
+ return getStartRow();
+
+ case STOP_ROW:
+ return getStopRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case START_ROW:
+ return isSetStartRow();
+ case STOP_ROW:
+ return isSetStopRow();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithStop_args)
+ return this.equals((scannerOpenWithStop_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithStop_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_startRow = true && this.isSetStartRow();
+ boolean that_present_startRow = true && that.isSetStartRow();
+ if (this_present_startRow || that_present_startRow) {
+ if (!(this_present_startRow && that_present_startRow))
+ return false;
+ if (!this.startRow.equals(that.startRow))
+ return false;
+ }
+
+ boolean this_present_stopRow = true && this.isSetStopRow();
+ boolean that_present_stopRow = true && that.isSetStopRow();
+ if (this_present_stopRow || that_present_stopRow) {
+ if (!(this_present_stopRow && that_present_stopRow))
+ return false;
+ if (!this.stopRow.equals(that.stopRow))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStartRow()) ? 131071 : 524287);
+ if (isSetStartRow())
+ hashCode = hashCode * 8191 + startRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStopRow()) ? 131071 : 524287);
+ if (isSetStopRow())
+ hashCode = hashCode * 8191 + stopRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithStop_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStartRow(), other.isSetStartRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, other.startRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStopRow(), other.isSetStopRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStopRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, other.stopRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithStop_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("startRow:");
+ if (this.startRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("stopRow:");
+ if (this.stopRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.stopRow, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithStop_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStop_argsStandardScheme getScheme() {
+ return new scannerOpenWithStop_argsStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithStop_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithStop_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithStop_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // START_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // STOP_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list504 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list504.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem505;
+ for (int _i506 = 0; _i506 < _list504.size; ++_i506)
+ {
+ _elem505 = iprot.readBinary();
+ struct.columns.add(_elem505);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map507 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map507.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key508;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val509;
+ for (int _i510 = 0; _i510 < _map507.size; ++_i510)
+ {
+ _key508 = iprot.readBinary();
+ _val509 = iprot.readBinary();
+ struct.attributes.put(_key508, _val509);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithStop_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.startRow != null) {
+ oprot.writeFieldBegin(START_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.startRow);
+ oprot.writeFieldEnd();
+ }
+ if (struct.stopRow != null) {
+ oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.stopRow);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter511 : struct.columns)
+ {
+ oprot.writeBinary(_iter511);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter512 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter512.getKey());
+ oprot.writeBinary(_iter512.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithStop_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStop_argsTupleScheme getScheme() {
+ return new scannerOpenWithStop_argsTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithStop_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithStop_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStop_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStartRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetStopRow()) {
+ optionals.set(2);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(3);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetStartRow()) {
+ oprot.writeBinary(struct.startRow);
+ }
+ if (struct.isSetStopRow()) {
+ oprot.writeBinary(struct.stopRow);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter513 : struct.columns)
+ {
+ oprot.writeBinary(_iter513);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter514 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter514.getKey());
+ oprot.writeBinary(_iter514.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStop_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TList _list515 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list515.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem516;
+ for (int _i517 = 0; _i517 < _list515.size; ++_i517)
+ {
+ _elem516 = iprot.readBinary();
+ struct.columns.add(_elem516);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(4)) {
+ {
+ org.apache.thrift.protocol.TMap _map518 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map518.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key519;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val520;
+ for (int _i521 = 0; _i521 < _map518.size; ++_i521)
+ {
+ _key519 = iprot.readBinary();
+ _val520 = iprot.readBinary();
+ struct.attributes.put(_key519, _val520);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithStop_result implements org.apache.thrift.TBase<scannerOpenWithStop_result, scannerOpenWithStop_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithStop_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithStop_resultTupleSchemeFactory();
+
+ public int success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_result.class, metaDataMap);
+ }
+
+ public scannerOpenWithStop_result() {
+ }
+
+ public scannerOpenWithStop_result(
+ int success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithStop_result(scannerOpenWithStop_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public scannerOpenWithStop_result deepCopy() {
+ return new scannerOpenWithStop_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ }
+
+ public int getSuccess() {
+ return this.success;
+ }
+
+ public scannerOpenWithStop_result setSuccess(int success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerOpenWithStop_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Integer)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithStop_result)
+ return this.equals((scannerOpenWithStop_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithStop_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + success;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithStop_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithStop_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithStop_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStop_resultStandardScheme getScheme() {
+ return new scannerOpenWithStop_resultStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithStop_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithStop_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithStop_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithStop_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithStop_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStop_resultTupleScheme getScheme() {
+ return new scannerOpenWithStop_resultTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithStop_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithStop_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStop_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStop_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithPrefix_args implements org.apache.thrift.TBase<scannerOpenWithPrefix_args, scannerOpenWithPrefix_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithPrefix_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithPrefix_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * the prefix (and thus start row) of the keys you want
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startAndPrefix; // required
+ /**
+ * the columns you want returned
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ /**
+ * Scan attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * the prefix (and thus start row) of the keys you want
+ */
+ START_AND_PREFIX((short)2, "startAndPrefix"),
+ /**
+ * the columns you want returned
+ */
+ COLUMNS((short)3, "columns"),
+ /**
+ * Scan attributes
+ */
+ ATTRIBUTES((short)4, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // START_AND_PREFIX
+ return START_AND_PREFIX;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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"))));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_args.class, metaDataMap);
+ }
+
+ public scannerOpenWithPrefix_args() {
+ }
+
+ public scannerOpenWithPrefix_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer startAndPrefix,
+ java.util.List<java.nio.ByteBuffer> columns,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.startAndPrefix = org.apache.thrift.TBaseHelper.copyBinary(startAndPrefix);
+ this.columns = columns;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithPrefix_args(scannerOpenWithPrefix_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetStartAndPrefix()) {
+ this.startAndPrefix = org.apache.thrift.TBaseHelper.copyBinary(other.startAndPrefix);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public scannerOpenWithPrefix_args deepCopy() {
+ return new scannerOpenWithPrefix_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.startAndPrefix = null;
+ this.columns = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public scannerOpenWithPrefix_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public scannerOpenWithPrefix_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * 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();
+ }
+
+ public java.nio.ByteBuffer bufferForStartAndPrefix() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startAndPrefix);
+ }
+
+ /**
+ * the prefix (and thus start row) of the keys you want
+ */
+ public scannerOpenWithPrefix_args setStartAndPrefix(byte[] startAndPrefix) {
+ this.startAndPrefix = startAndPrefix == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startAndPrefix.clone());
+ return this;
+ }
+
+ public scannerOpenWithPrefix_args setStartAndPrefix(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startAndPrefix) {
+ this.startAndPrefix = org.apache.thrift.TBaseHelper.copyBinary(startAndPrefix);
+ return this;
+ }
+
+ public void unsetStartAndPrefix() {
+ this.startAndPrefix = null;
+ }
+
+ /** Returns true if field startAndPrefix is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartAndPrefix() {
+ return this.startAndPrefix != null;
+ }
+
+ public void setStartAndPrefixIsSet(boolean value) {
+ if (!value) {
+ this.startAndPrefix = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * the columns you want returned
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * the columns you want returned
+ */
+ public scannerOpenWithPrefix_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Scan attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Scan attributes
+ */
+ public scannerOpenWithPrefix_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case START_AND_PREFIX:
+ if (value == null) {
+ unsetStartAndPrefix();
+ } else {
+ if (value instanceof byte[]) {
+ setStartAndPrefix((byte[])value);
+ } else {
+ setStartAndPrefix((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case START_AND_PREFIX:
+ return getStartAndPrefix();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case START_AND_PREFIX:
+ return isSetStartAndPrefix();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithPrefix_args)
+ return this.equals((scannerOpenWithPrefix_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithPrefix_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_startAndPrefix = true && this.isSetStartAndPrefix();
+ boolean that_present_startAndPrefix = true && that.isSetStartAndPrefix();
+ if (this_present_startAndPrefix || that_present_startAndPrefix) {
+ if (!(this_present_startAndPrefix && that_present_startAndPrefix))
+ return false;
+ if (!this.startAndPrefix.equals(that.startAndPrefix))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStartAndPrefix()) ? 131071 : 524287);
+ if (isSetStartAndPrefix())
+ hashCode = hashCode * 8191 + startAndPrefix.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithPrefix_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStartAndPrefix(), other.isSetStartAndPrefix());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartAndPrefix()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startAndPrefix, other.startAndPrefix);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithPrefix_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("startAndPrefix:");
+ if (this.startAndPrefix == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startAndPrefix, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithPrefix_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithPrefix_argsStandardScheme getScheme() {
+ return new scannerOpenWithPrefix_argsStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithPrefix_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithPrefix_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithPrefix_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // START_AND_PREFIX
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startAndPrefix = iprot.readBinary();
+ struct.setStartAndPrefixIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list522 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list522.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem523;
+ for (int _i524 = 0; _i524 < _list522.size; ++_i524)
+ {
+ _elem523 = iprot.readBinary();
+ struct.columns.add(_elem523);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map525 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map525.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key526;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val527;
+ for (int _i528 = 0; _i528 < _map525.size; ++_i528)
+ {
+ _key526 = iprot.readBinary();
+ _val527 = iprot.readBinary();
+ struct.attributes.put(_key526, _val527);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithPrefix_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.startAndPrefix != null) {
+ oprot.writeFieldBegin(START_AND_PREFIX_FIELD_DESC);
+ oprot.writeBinary(struct.startAndPrefix);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter529 : struct.columns)
+ {
+ oprot.writeBinary(_iter529);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter530 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter530.getKey());
+ oprot.writeBinary(_iter530.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithPrefix_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithPrefix_argsTupleScheme getScheme() {
+ return new scannerOpenWithPrefix_argsTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithPrefix_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithPrefix_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithPrefix_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStartAndPrefix()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetStartAndPrefix()) {
+ oprot.writeBinary(struct.startAndPrefix);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter531 : struct.columns)
+ {
+ oprot.writeBinary(_iter531);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter532 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter532.getKey());
+ oprot.writeBinary(_iter532.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithPrefix_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.startAndPrefix = iprot.readBinary();
+ struct.setStartAndPrefixIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list533 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list533.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem534;
+ for (int _i535 = 0; _i535 < _list533.size; ++_i535)
+ {
+ _elem534 = iprot.readBinary();
+ struct.columns.add(_elem534);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map536 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map536.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key537;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val538;
+ for (int _i539 = 0; _i539 < _map536.size; ++_i539)
+ {
+ _key537 = iprot.readBinary();
+ _val538 = iprot.readBinary();
+ struct.attributes.put(_key537, _val538);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithPrefix_result implements org.apache.thrift.TBase<scannerOpenWithPrefix_result, scannerOpenWithPrefix_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithPrefix_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithPrefix_resultTupleSchemeFactory();
+
+ public int success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_result.class, metaDataMap);
+ }
+
+ public scannerOpenWithPrefix_result() {
+ }
+
+ public scannerOpenWithPrefix_result(
+ int success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithPrefix_result(scannerOpenWithPrefix_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public scannerOpenWithPrefix_result deepCopy() {
+ return new scannerOpenWithPrefix_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ }
+
+ public int getSuccess() {
+ return this.success;
+ }
+
+ public scannerOpenWithPrefix_result setSuccess(int success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerOpenWithPrefix_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Integer)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithPrefix_result)
+ return this.equals((scannerOpenWithPrefix_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithPrefix_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + success;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithPrefix_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithPrefix_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithPrefix_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithPrefix_resultStandardScheme getScheme() {
+ return new scannerOpenWithPrefix_resultStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithPrefix_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithPrefix_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithPrefix_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithPrefix_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithPrefix_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithPrefix_resultTupleScheme getScheme() {
+ return new scannerOpenWithPrefix_resultTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithPrefix_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithPrefix_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithPrefix_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithPrefix_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenTs_args implements org.apache.thrift.TBase<scannerOpenTs_args, scannerOpenTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow; // required
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Scan attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ START_ROW((short)2, "startRow"),
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ COLUMNS((short)3, "columns"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)4, "timestamp"),
+ /**
+ * Scan attributes
+ */
+ ATTRIBUTES((short)5, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // START_ROW
+ return START_ROW;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenTs_args.class, metaDataMap);
+ }
+
+ public scannerOpenTs_args() {
+ }
+
+ public scannerOpenTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer startRow,
+ java.util.List<java.nio.ByteBuffer> columns,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ this.columns = columns;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenTs_args(scannerOpenTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetStartRow()) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public scannerOpenTs_args deepCopy() {
+ return new scannerOpenTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.startRow = null;
+ this.columns = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public scannerOpenTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public scannerOpenTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * Starting row in table to scan.
+ * 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();
+ }
+
+ public java.nio.ByteBuffer bufferForStartRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ }
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public scannerOpenTs_args setStartRow(byte[] startRow) {
+ this.startRow = startRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startRow.clone());
+ return this;
+ }
+
+ public scannerOpenTs_args setStartRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ return this;
+ }
+
+ public void unsetStartRow() {
+ this.startRow = null;
+ }
+
+ /** Returns true if field startRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartRow() {
+ return this.startRow != null;
+ }
+
+ public void setStartRowIsSet(boolean value) {
+ if (!value) {
+ this.startRow = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public scannerOpenTs_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public scannerOpenTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Scan attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Scan attributes
+ */
+ public scannerOpenTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case START_ROW:
+ if (value == null) {
+ unsetStartRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStartRow((byte[])value);
+ } else {
+ setStartRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case START_ROW:
+ return getStartRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case START_ROW:
+ return isSetStartRow();
+ case COLUMNS:
+ return isSetColumns();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenTs_args)
+ return this.equals((scannerOpenTs_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_startRow = true && this.isSetStartRow();
+ boolean that_present_startRow = true && that.isSetStartRow();
+ if (this_present_startRow || that_present_startRow) {
+ if (!(this_present_startRow && that_present_startRow))
+ return false;
+ if (!this.startRow.equals(that.startRow))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStartRow()) ? 131071 : 524287);
+ if (isSetStartRow())
+ hashCode = hashCode * 8191 + startRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStartRow(), other.isSetStartRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, other.startRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("startRow:");
+ if (this.startRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenTs_argsStandardScheme getScheme() {
+ return new scannerOpenTs_argsStandardScheme();
+ }
+ }
+
+ private static class scannerOpenTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // START_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list540 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list540.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem541;
+ for (int _i542 = 0; _i542 < _list540.size; ++_i542)
+ {
+ _elem541 = iprot.readBinary();
+ struct.columns.add(_elem541);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map543 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map543.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key544;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val545;
+ for (int _i546 = 0; _i546 < _map543.size; ++_i546)
+ {
+ _key544 = iprot.readBinary();
+ _val545 = iprot.readBinary();
+ struct.attributes.put(_key544, _val545);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.startRow != null) {
+ oprot.writeFieldBegin(START_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.startRow);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter547 : struct.columns)
+ {
+ oprot.writeBinary(_iter547);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter548 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter548.getKey());
+ oprot.writeBinary(_iter548.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenTs_argsTupleScheme getScheme() {
+ return new scannerOpenTs_argsTupleScheme();
+ }
+ }
+
+ private static class scannerOpenTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStartRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(3);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetStartRow()) {
+ oprot.writeBinary(struct.startRow);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter549 : struct.columns)
+ {
+ oprot.writeBinary(_iter549);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter550 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter550.getKey());
+ oprot.writeBinary(_iter550.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list551 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list551.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem552;
+ for (int _i553 = 0; _i553 < _list551.size; ++_i553)
+ {
+ _elem552 = iprot.readBinary();
+ struct.columns.add(_elem552);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(4)) {
+ {
+ org.apache.thrift.protocol.TMap _map554 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map554.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key555;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val556;
+ for (int _i557 = 0; _i557 < _map554.size; ++_i557)
+ {
+ _key555 = iprot.readBinary();
+ _val556 = iprot.readBinary();
+ struct.attributes.put(_key555, _val556);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenTs_result implements org.apache.thrift.TBase<scannerOpenTs_result, scannerOpenTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenTs_resultTupleSchemeFactory();
+
+ public int success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenTs_result.class, metaDataMap);
+ }
+
+ public scannerOpenTs_result() {
+ }
+
+ public scannerOpenTs_result(
+ int success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenTs_result(scannerOpenTs_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public scannerOpenTs_result deepCopy() {
+ return new scannerOpenTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ }
+
+ public int getSuccess() {
+ return this.success;
+ }
+
+ public scannerOpenTs_result setSuccess(int success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerOpenTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Integer)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenTs_result)
+ return this.equals((scannerOpenTs_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + success;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenTs_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenTs_resultStandardScheme getScheme() {
+ return new scannerOpenTs_resultStandardScheme();
+ }
+ }
+
+ private static class scannerOpenTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenTs_resultTupleScheme getScheme() {
+ return new scannerOpenTs_resultTupleScheme();
+ }
+ }
+
+ private static class scannerOpenTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithStopTs_args implements org.apache.thrift.TBase<scannerOpenWithStopTs_args, scannerOpenWithStopTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_args> {
+ 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithStopTs_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithStopTs_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow; // required
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow; // required
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ /**
+ * timestamp
+ */
+ public long timestamp; // required
+ /**
+ * Scan attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ START_ROW((short)2, "startRow"),
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ STOP_ROW((short)3, "stopRow"),
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ COLUMNS((short)4, "columns"),
+ /**
+ * timestamp
+ */
+ TIMESTAMP((short)5, "timestamp"),
+ /**
+ * Scan attributes
+ */
+ ATTRIBUTES((short)6, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // START_ROW
+ return START_ROW;
+ case 3: // STOP_ROW
+ return STOP_ROW;
+ case 4: // COLUMNS
+ return COLUMNS;
+ case 5: // TIMESTAMP
+ return TIMESTAMP;
+ case 6: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_args.class, metaDataMap);
+ }
+
+ public scannerOpenWithStopTs_args() {
+ }
+
+ public scannerOpenWithStopTs_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer startRow,
+ java.nio.ByteBuffer stopRow,
+ java.util.List<java.nio.ByteBuffer> columns,
+ long timestamp,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ this.columns = columns;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithStopTs_args(scannerOpenWithStopTs_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetStartRow()) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
+ }
+ if (other.isSetStopRow()) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(other.stopRow);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public scannerOpenWithStopTs_args deepCopy() {
+ return new scannerOpenWithStopTs_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.startRow = null;
+ this.stopRow = null;
+ this.columns = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public scannerOpenWithStopTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public scannerOpenWithStopTs_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * Starting row in table to scan.
+ * 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();
+ }
+
+ public java.nio.ByteBuffer bufferForStartRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ }
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ public scannerOpenWithStopTs_args setStartRow(byte[] startRow) {
+ this.startRow = startRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startRow.clone());
+ return this;
+ }
+
+ public scannerOpenWithStopTs_args setStartRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ return this;
+ }
+
+ public void unsetStartRow() {
+ this.startRow = null;
+ }
+
+ /** Returns true if field startRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartRow() {
+ return this.startRow != null;
+ }
+
+ public void setStartRowIsSet(boolean value) {
+ if (!value) {
+ this.startRow = null;
+ }
+ }
+
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ public byte[] getStopRow() {
+ setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow));
+ return stopRow == null ? null : stopRow.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStopRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ }
+
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ public scannerOpenWithStopTs_args setStopRow(byte[] stopRow) {
+ this.stopRow = stopRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(stopRow.clone());
+ return this;
+ }
+
+ public scannerOpenWithStopTs_args setStopRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ return this;
+ }
+
+ public void unsetStopRow() {
+ this.stopRow = null;
+ }
+
+ /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStopRow() {
+ return this.stopRow != null;
+ }
+
+ public void setStopRowIsSet(boolean value) {
+ if (!value) {
+ this.stopRow = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ public scannerOpenWithStopTs_args setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ /**
+ * timestamp
+ */
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ /**
+ * timestamp
+ */
+ public scannerOpenWithStopTs_args setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Scan attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Scan attributes
+ */
+ public scannerOpenWithStopTs_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case START_ROW:
+ if (value == null) {
+ unsetStartRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStartRow((byte[])value);
+ } else {
+ setStartRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case STOP_ROW:
+ if (value == null) {
+ unsetStopRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStopRow((byte[])value);
+ } else {
+ setStopRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case START_ROW:
+ return getStartRow();
+
+ case STOP_ROW:
+ return getStopRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case START_ROW:
+ return isSetStartRow();
+ case STOP_ROW:
+ return isSetStopRow();
+ case COLUMNS:
+ return isSetColumns();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithStopTs_args)
+ return this.equals((scannerOpenWithStopTs_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithStopTs_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_startRow = true && this.isSetStartRow();
+ boolean that_present_startRow = true && that.isSetStartRow();
+ if (this_present_startRow || that_present_startRow) {
+ if (!(this_present_startRow && that_present_startRow))
+ return false;
+ if (!this.startRow.equals(that.startRow))
+ return false;
+ }
+
+ boolean this_present_stopRow = true && this.isSetStopRow();
+ boolean that_present_stopRow = true && that.isSetStopRow();
+ if (this_present_stopRow || that_present_stopRow) {
+ if (!(this_present_stopRow && that_present_stopRow))
+ return false;
+ if (!this.stopRow.equals(that.stopRow))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStartRow()) ? 131071 : 524287);
+ if (isSetStartRow())
+ hashCode = hashCode * 8191 + startRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStopRow()) ? 131071 : 524287);
+ if (isSetStopRow())
+ hashCode = hashCode * 8191 + stopRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithStopTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStartRow(), other.isSetStartRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, other.startRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStopRow(), other.isSetStopRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStopRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, other.stopRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithStopTs_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("startRow:");
+ if (this.startRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("stopRow:");
+ if (this.stopRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.stopRow, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithStopTs_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStopTs_argsStandardScheme getScheme() {
+ return new scannerOpenWithStopTs_argsStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithStopTs_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithStopTs_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithStopTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // START_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // STOP_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list558 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list558.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem559;
+ for (int _i560 = 0; _i560 < _list558.size; ++_i560)
+ {
+ _elem559 = iprot.readBinary();
+ struct.columns.add(_elem559);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map561 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map561.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key562;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val563;
+ for (int _i564 = 0; _i564 < _map561.size; ++_i564)
+ {
+ _key562 = iprot.readBinary();
+ _val563 = iprot.readBinary();
+ struct.attributes.put(_key562, _val563);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithStopTs_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.startRow != null) {
+ oprot.writeFieldBegin(START_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.startRow);
+ oprot.writeFieldEnd();
+ }
+ if (struct.stopRow != null) {
+ oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.stopRow);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter565 : struct.columns)
+ {
+ oprot.writeBinary(_iter565);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter566 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter566.getKey());
+ oprot.writeBinary(_iter566.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithStopTs_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStopTs_argsTupleScheme getScheme() {
+ return new scannerOpenWithStopTs_argsTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithStopTs_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithStopTs_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStopTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStartRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetStopRow()) {
+ optionals.set(2);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(3);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(4);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(5);
+ }
+ oprot.writeBitSet(optionals, 6);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetStartRow()) {
+ oprot.writeBinary(struct.startRow);
+ }
+ if (struct.isSetStopRow()) {
+ oprot.writeBinary(struct.stopRow);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter567 : struct.columns)
+ {
+ oprot.writeBinary(_iter567);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter568 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter568.getKey());
+ oprot.writeBinary(_iter568.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStopTs_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(6);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TList _list569 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list569.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem570;
+ for (int _i571 = 0; _i571 < _list569.size; ++_i571)
+ {
+ _elem570 = iprot.readBinary();
+ struct.columns.add(_elem570);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(5)) {
+ {
+ org.apache.thrift.protocol.TMap _map572 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map572.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key573;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val574;
+ for (int _i575 = 0; _i575 < _map572.size; ++_i575)
+ {
+ _key573 = iprot.readBinary();
+ _val574 = iprot.readBinary();
+ struct.attributes.put(_key573, _val574);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerOpenWithStopTs_result implements org.apache.thrift.TBase<scannerOpenWithStopTs_result, scannerOpenWithStopTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerOpenWithStopTs_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerOpenWithStopTs_resultTupleSchemeFactory();
+
+ public int success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_result.class, metaDataMap);
+ }
+
+ public scannerOpenWithStopTs_result() {
+ }
+
+ public scannerOpenWithStopTs_result(
+ int success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerOpenWithStopTs_result(scannerOpenWithStopTs_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public scannerOpenWithStopTs_result deepCopy() {
+ return new scannerOpenWithStopTs_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ }
+
+ public int getSuccess() {
+ return this.success;
+ }
+
+ public scannerOpenWithStopTs_result setSuccess(int success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerOpenWithStopTs_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Integer)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerOpenWithStopTs_result)
+ return this.equals((scannerOpenWithStopTs_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerOpenWithStopTs_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + success;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerOpenWithStopTs_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerOpenWithStopTs_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerOpenWithStopTs_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStopTs_resultStandardScheme getScheme() {
+ return new scannerOpenWithStopTs_resultStandardScheme();
+ }
+ }
+
+ private static class scannerOpenWithStopTs_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerOpenWithStopTs_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerOpenWithStopTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerOpenWithStopTs_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerOpenWithStopTs_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerOpenWithStopTs_resultTupleScheme getScheme() {
+ return new scannerOpenWithStopTs_resultTupleScheme();
+ }
+ }
+
+ private static class scannerOpenWithStopTs_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerOpenWithStopTs_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStopTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerOpenWithStopTs_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerGet_args implements org.apache.thrift.TBase<scannerGet_args, scannerGet_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGet_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerGet_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerGet_argsTupleSchemeFactory();
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public int id; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ ID((short)1, "id");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ID
+ return ID;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __ID_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGet_args.class, metaDataMap);
+ }
+
+ public scannerGet_args() {
+ }
+
+ public scannerGet_args(
+ int id)
+ {
+ this();
+ this.id = id;
+ setIdIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerGet_args(scannerGet_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.id = other.id;
+ }
+
+ public scannerGet_args deepCopy() {
+ return new scannerGet_args(this);
+ }
+
+ @Override
+ public void clear() {
+ setIdIsSet(false);
+ this.id = 0;
+ }
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public int getId() {
+ return this.id;
+ }
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public scannerGet_args setId(int id) {
+ this.id = id;
+ setIdIsSet(true);
+ return this;
+ }
+
+ public void unsetId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ /** Returns true if field id is set (has been assigned a value) and false otherwise */
+ public boolean isSetId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ public void setIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ID_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ID:
+ if (value == null) {
+ unsetId();
+ } else {
+ setId((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ID:
+ return getId();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ID:
+ return isSetId();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerGet_args)
+ return this.equals((scannerGet_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerGet_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_id = true;
+ boolean that_present_id = true;
+ if (this_present_id || that_present_id) {
+ if (!(this_present_id && that_present_id))
+ return false;
+ if (this.id != that.id)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + id;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerGet_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetId(), other.isSetId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, other.id);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerGet_args(");
+ boolean first = true;
+
+ sb.append("id:");
+ sb.append(this.id);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerGet_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGet_argsStandardScheme getScheme() {
+ return new scannerGet_argsStandardScheme();
+ }
+ }
+
+ private static class scannerGet_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerGet_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerGet_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.id = iprot.readI32();
+ struct.setIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerGet_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(ID_FIELD_DESC);
+ oprot.writeI32(struct.id);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerGet_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGet_argsTupleScheme getScheme() {
+ return new scannerGet_argsTupleScheme();
+ }
+ }
+
+ private static class scannerGet_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerGet_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerGet_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetId()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetId()) {
+ oprot.writeI32(struct.id);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerGet_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.id = iprot.readI32();
+ struct.setIdIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerGet_result implements org.apache.thrift.TBase<scannerGet_result, scannerGet_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGet_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerGet_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerGet_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGet_result.class, metaDataMap);
+ }
+
+ public scannerGet_result() {
+ }
+
+ public scannerGet_result(
+ java.util.List<TRowResult> success,
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerGet_result(scannerGet_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public scannerGet_result deepCopy() {
+ return new scannerGet_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ this.ia = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public scannerGet_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerGet_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public scannerGet_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerGet_result)
+ return this.equals((scannerGet_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerGet_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerGet_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerGet_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerGet_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGet_resultStandardScheme getScheme() {
+ return new scannerGet_resultStandardScheme();
+ }
+ }
+
+ private static class scannerGet_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerGet_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerGet_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list576 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list576.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem577;
+ for (int _i578 = 0; _i578 < _list576.size; ++_i578)
+ {
+ _elem577 = new TRowResult();
+ _elem577.read(iprot);
+ struct.success.add(_elem577);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerGet_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter579 : struct.success)
+ {
+ _iter579.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerGet_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGet_resultTupleScheme getScheme() {
+ return new scannerGet_resultTupleScheme();
+ }
+ }
+
+ private static class scannerGet_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerGet_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerGet_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter580 : struct.success)
+ {
+ _iter580.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerGet_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list581 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list581.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem582;
+ for (int _i583 = 0; _i583 < _list581.size; ++_i583)
+ {
+ _elem582 = new TRowResult();
+ _elem582.read(iprot);
+ struct.success.add(_elem582);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerGetList_args implements org.apache.thrift.TBase<scannerGetList_args, scannerGetList_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGetList_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerGetList_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerGetList_argsTupleSchemeFactory();
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public int id; // required
+ /**
+ * number of results to return
+ */
+ public int nbRows; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ ID((short)1, "id"),
+ /**
+ * number of results to return
+ */
+ NB_ROWS((short)2, "nbRows");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ID
+ return ID;
+ case 2: // NB_ROWS
+ return NB_ROWS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __ID_ISSET_ID = 0;
+ private static final int __NBROWS_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGetList_args.class, metaDataMap);
+ }
+
+ public scannerGetList_args() {
+ }
+
+ public scannerGetList_args(
+ int id,
+ int nbRows)
+ {
+ this();
+ this.id = id;
+ setIdIsSet(true);
+ this.nbRows = nbRows;
+ setNbRowsIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerGetList_args(scannerGetList_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.id = other.id;
+ this.nbRows = other.nbRows;
+ }
+
+ public scannerGetList_args deepCopy() {
+ return new scannerGetList_args(this);
+ }
+
+ @Override
+ public void clear() {
+ setIdIsSet(false);
+ this.id = 0;
+ setNbRowsIsSet(false);
+ this.nbRows = 0;
+ }
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public int getId() {
+ return this.id;
+ }
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public scannerGetList_args setId(int id) {
+ this.id = id;
+ setIdIsSet(true);
+ return this;
+ }
+
+ public void unsetId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ /** Returns true if field id is set (has been assigned a value) and false otherwise */
+ public boolean isSetId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ public void setIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ID_ISSET_ID, value);
+ }
+
+ /**
+ * number of results to return
+ */
+ public int getNbRows() {
+ return this.nbRows;
+ }
+
+ /**
+ * number of results to return
+ */
+ public scannerGetList_args setNbRows(int nbRows) {
+ this.nbRows = nbRows;
+ setNbRowsIsSet(true);
+ return this;
+ }
+
+ public void unsetNbRows() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __NBROWS_ISSET_ID);
+ }
+
+ /** Returns true if field nbRows is set (has been assigned a value) and false otherwise */
+ public boolean isSetNbRows() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __NBROWS_ISSET_ID);
+ }
+
+ public void setNbRowsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __NBROWS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ID:
+ if (value == null) {
+ unsetId();
+ } else {
+ setId((java.lang.Integer)value);
+ }
+ break;
+
+ case NB_ROWS:
+ if (value == null) {
+ unsetNbRows();
+ } else {
+ setNbRows((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ID:
+ return getId();
+
+ case NB_ROWS:
+ return getNbRows();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ID:
+ return isSetId();
+ case NB_ROWS:
+ return isSetNbRows();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerGetList_args)
+ return this.equals((scannerGetList_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerGetList_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_id = true;
+ boolean that_present_id = true;
+ if (this_present_id || that_present_id) {
+ if (!(this_present_id && that_present_id))
+ return false;
+ if (this.id != that.id)
+ return false;
+ }
+
+ boolean this_present_nbRows = true;
+ boolean that_present_nbRows = true;
+ if (this_present_nbRows || that_present_nbRows) {
+ if (!(this_present_nbRows && that_present_nbRows))
+ return false;
+ if (this.nbRows != that.nbRows)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + id;
+
+ hashCode = hashCode * 8191 + nbRows;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerGetList_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetId(), other.isSetId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, other.id);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetNbRows(), other.isSetNbRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNbRows()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nbRows, other.nbRows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerGetList_args(");
+ boolean first = true;
+
+ sb.append("id:");
+ sb.append(this.id);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("nbRows:");
+ sb.append(this.nbRows);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerGetList_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGetList_argsStandardScheme getScheme() {
+ return new scannerGetList_argsStandardScheme();
+ }
+ }
+
+ private static class scannerGetList_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerGetList_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerGetList_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.id = iprot.readI32();
+ struct.setIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // NB_ROWS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.nbRows = iprot.readI32();
+ struct.setNbRowsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerGetList_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(ID_FIELD_DESC);
+ oprot.writeI32(struct.id);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(NB_ROWS_FIELD_DESC);
+ oprot.writeI32(struct.nbRows);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerGetList_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGetList_argsTupleScheme getScheme() {
+ return new scannerGetList_argsTupleScheme();
+ }
+ }
+
+ private static class scannerGetList_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerGetList_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerGetList_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetId()) {
+ optionals.set(0);
+ }
+ if (struct.isSetNbRows()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetId()) {
+ oprot.writeI32(struct.id);
+ }
+ if (struct.isSetNbRows()) {
+ oprot.writeI32(struct.nbRows);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerGetList_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.id = iprot.readI32();
+ struct.setIdIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.nbRows = iprot.readI32();
+ struct.setNbRowsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerGetList_result implements org.apache.thrift.TBase<scannerGetList_result, scannerGetList_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGetList_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerGetList_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerGetList_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerGetList_result.class, metaDataMap);
+ }
+
+ public scannerGetList_result() {
+ }
+
+ public scannerGetList_result(
+ java.util.List<TRowResult> success,
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerGetList_result(scannerGetList_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TRowResult> __this__success = new java.util.ArrayList<TRowResult>(other.success.size());
+ for (TRowResult other_element : other.success) {
+ __this__success.add(new TRowResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public scannerGetList_result deepCopy() {
+ return new scannerGetList_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ this.ia = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public scannerGetList_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerGetList_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public scannerGetList_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerGetList_result)
+ return this.equals((scannerGetList_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerGetList_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerGetList_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerGetList_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerGetList_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGetList_resultStandardScheme getScheme() {
+ return new scannerGetList_resultStandardScheme();
+ }
+ }
+
+ private static class scannerGetList_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerGetList_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerGetList_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list584 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TRowResult>(_list584.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem585;
+ for (int _i586 = 0; _i586 < _list584.size; ++_i586)
+ {
+ _elem585 = new TRowResult();
+ _elem585.read(iprot);
+ struct.success.add(_elem585);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerGetList_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TRowResult _iter587 : struct.success)
+ {
+ _iter587.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerGetList_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerGetList_resultTupleScheme getScheme() {
+ return new scannerGetList_resultTupleScheme();
+ }
+ }
+
+ private static class scannerGetList_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerGetList_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerGetList_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TRowResult _iter588 : struct.success)
+ {
+ _iter588.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerGetList_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list589 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TRowResult>(_list589.size);
+ @org.apache.thrift.annotation.Nullable TRowResult _elem590;
+ for (int _i591 = 0; _i591 < _list589.size; ++_i591)
+ {
+ _elem590 = new TRowResult();
+ _elem590.read(iprot);
+ struct.success.add(_elem590);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerClose_args implements org.apache.thrift.TBase<scannerClose_args, scannerClose_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_args> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerClose_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerClose_argsTupleSchemeFactory();
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public int id; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ ID((short)1, "id");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ID
+ return ID;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __ID_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerClose_args.class, metaDataMap);
+ }
+
+ public scannerClose_args() {
+ }
+
+ public scannerClose_args(
+ int id)
+ {
+ this();
+ this.id = id;
+ setIdIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerClose_args(scannerClose_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.id = other.id;
+ }
+
+ public scannerClose_args deepCopy() {
+ return new scannerClose_args(this);
+ }
+
+ @Override
+ public void clear() {
+ setIdIsSet(false);
+ this.id = 0;
+ }
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public int getId() {
+ return this.id;
+ }
+
+ /**
+ * id of a scanner returned by scannerOpen
+ */
+ public scannerClose_args setId(int id) {
+ this.id = id;
+ setIdIsSet(true);
+ return this;
+ }
+
+ public void unsetId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ /** Returns true if field id is set (has been assigned a value) and false otherwise */
+ public boolean isSetId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ public void setIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ID_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ID:
+ if (value == null) {
+ unsetId();
+ } else {
+ setId((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ID:
+ return getId();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ID:
+ return isSetId();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerClose_args)
+ return this.equals((scannerClose_args)that);
+ return false;
+ }
+
+ public boolean equals(scannerClose_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_id = true;
+ boolean that_present_id = true;
+ if (this_present_id || that_present_id) {
+ if (!(this_present_id && that_present_id))
+ return false;
+ if (this.id != that.id)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + id;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerClose_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetId(), other.isSetId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, other.id);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerClose_args(");
+ boolean first = true;
+
+ sb.append("id:");
+ sb.append(this.id);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerClose_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerClose_argsStandardScheme getScheme() {
+ return new scannerClose_argsStandardScheme();
+ }
+ }
+
+ private static class scannerClose_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerClose_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerClose_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.id = iprot.readI32();
+ struct.setIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerClose_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(ID_FIELD_DESC);
+ oprot.writeI32(struct.id);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerClose_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerClose_argsTupleScheme getScheme() {
+ return new scannerClose_argsTupleScheme();
+ }
+ }
+
+ private static class scannerClose_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerClose_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerClose_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetId()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetId()) {
+ oprot.writeI32(struct.id);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerClose_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.id = iprot.readI32();
+ struct.setIdIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class scannerClose_result implements org.apache.thrift.TBase<scannerClose_result, scannerClose_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new scannerClose_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new scannerClose_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(scannerClose_result.class, metaDataMap);
+ }
+
+ public scannerClose_result() {
+ }
+
+ public scannerClose_result(
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public scannerClose_result(scannerClose_result other) {
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public scannerClose_result deepCopy() {
+ return new scannerClose_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ this.ia = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public scannerClose_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public scannerClose_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof scannerClose_result)
+ return this.equals((scannerClose_result)that);
+ return false;
+ }
+
+ public boolean equals(scannerClose_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(scannerClose_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("scannerClose_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class scannerClose_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerClose_resultStandardScheme getScheme() {
+ return new scannerClose_resultStandardScheme();
+ }
+ }
+
+ private static class scannerClose_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<scannerClose_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, scannerClose_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, scannerClose_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class scannerClose_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public scannerClose_resultTupleScheme getScheme() {
+ return new scannerClose_resultTupleScheme();
+ }
+ }
+
+ private static class scannerClose_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<scannerClose_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, scannerClose_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, scannerClose_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRegionInfo_args implements org.apache.thrift.TBase<getRegionInfo_args, getRegionInfo_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRegionInfo_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRegionInfo_args");
+
+ 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)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRegionInfo_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRegionInfo_argsTupleSchemeFactory();
+
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * row key
+ */
+ ROW((short)1, "row");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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")));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRegionInfo_args.class, metaDataMap);
+ }
+
+ public getRegionInfo_args() {
+ }
+
+ public getRegionInfo_args(
+ java.nio.ByteBuffer row)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRegionInfo_args(getRegionInfo_args other) {
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ }
+
+ public getRegionInfo_args deepCopy() {
+ return new getRegionInfo_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public getRegionInfo_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getRegionInfo_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRegionInfo_args)
+ return this.equals((getRegionInfo_args)that);
+ return false;
+ }
+
+ public boolean equals(getRegionInfo_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRegionInfo_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRegionInfo_args(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRegionInfo_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionInfo_argsStandardScheme getScheme() {
+ return new getRegionInfo_argsStandardScheme();
+ }
+ }
+
+ private static class getRegionInfo_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRegionInfo_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRegionInfo_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRegionInfo_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRegionInfo_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionInfo_argsTupleScheme getScheme() {
+ return new getRegionInfo_argsTupleScheme();
+ }
+ }
+
+ private static class getRegionInfo_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRegionInfo_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRegionInfo_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRow()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRegionInfo_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRegionInfo_result implements org.apache.thrift.TBase<getRegionInfo_result, getRegionInfo_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRegionInfo_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRegionInfo_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRegionInfo_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRegionInfo_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TRegionInfo success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRegionInfo_result.class, metaDataMap);
+ }
+
+ public getRegionInfo_result() {
+ }
+
+ public getRegionInfo_result(
+ TRegionInfo success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRegionInfo_result(getRegionInfo_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TRegionInfo(other.success);
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public getRegionInfo_result deepCopy() {
+ return new getRegionInfo_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TRegionInfo getSuccess() {
+ return this.success;
+ }
+
+ public getRegionInfo_result setSuccess(@org.apache.thrift.annotation.Nullable TRegionInfo success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public getRegionInfo_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TRegionInfo)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRegionInfo_result)
+ return this.equals((getRegionInfo_result)that);
+ return false;
+ }
+
+ public boolean equals(getRegionInfo_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRegionInfo_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRegionInfo_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRegionInfo_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionInfo_resultStandardScheme getScheme() {
+ return new getRegionInfo_resultStandardScheme();
+ }
+ }
+
+ private static class getRegionInfo_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRegionInfo_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRegionInfo_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TRegionInfo();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRegionInfo_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRegionInfo_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionInfo_resultTupleScheme getScheme() {
+ return new getRegionInfo_resultTupleScheme();
+ }
+ }
+
+ private static class getRegionInfo_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRegionInfo_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRegionInfo_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRegionInfo_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = new TRegionInfo();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class append_args implements org.apache.thrift.TBase<append_args, append_args._Fields>, java.io.Serializable, Cloneable, Comparable<append_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("append_args");
+
+ private static final org.apache.thrift.protocol.TField APPEND_FIELD_DESC = new org.apache.thrift.protocol.TField("append", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new append_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new append_argsTupleSchemeFactory();
+
+ /**
+ * The single append operation to apply
+ */
+ public @org.apache.thrift.annotation.Nullable TAppend append; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * The single append operation to apply
+ */
+ APPEND((short)1, "append");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // APPEND
+ return APPEND;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.APPEND, new org.apache.thrift.meta_data.FieldMetaData("append", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAppend.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(append_args.class, metaDataMap);
+ }
+
+ public append_args() {
+ }
+
+ public append_args(
+ TAppend append)
+ {
+ this();
+ this.append = append;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public append_args(append_args other) {
+ if (other.isSetAppend()) {
+ this.append = new TAppend(other.append);
+ }
+ }
+
+ public append_args deepCopy() {
+ return new append_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.append = null;
+ }
+
+ /**
+ * The single append operation to apply
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TAppend getAppend() {
+ return this.append;
+ }
+
+ /**
+ * The single append operation to apply
+ */
+ public append_args setAppend(@org.apache.thrift.annotation.Nullable TAppend append) {
+ this.append = append;
+ return this;
+ }
+
+ public void unsetAppend() {
+ this.append = null;
+ }
+
+ /** Returns true if field append is set (has been assigned a value) and false otherwise */
+ public boolean isSetAppend() {
+ return this.append != null;
+ }
+
+ public void setAppendIsSet(boolean value) {
+ if (!value) {
+ this.append = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case APPEND:
+ if (value == null) {
+ unsetAppend();
+ } else {
+ setAppend((TAppend)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case APPEND:
+ return getAppend();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case APPEND:
+ return isSetAppend();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof append_args)
+ return this.equals((append_args)that);
+ return false;
+ }
+
+ public boolean equals(append_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_append = true && this.isSetAppend();
+ boolean that_present_append = true && that.isSetAppend();
+ if (this_present_append || that_present_append) {
+ if (!(this_present_append && that_present_append))
+ return false;
+ if (!this.append.equals(that.append))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetAppend()) ? 131071 : 524287);
+ if (isSetAppend())
+ hashCode = hashCode * 8191 + append.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(append_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetAppend(), other.isSetAppend());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAppend()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.append, other.append);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("append_args(");
+ boolean first = true;
+
+ sb.append("append:");
+ if (this.append == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.append);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (append != null) {
+ append.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class append_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_argsStandardScheme getScheme() {
+ return new append_argsStandardScheme();
+ }
+ }
+
+ private static class append_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<append_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, append_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // APPEND
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.append = new TAppend();
+ struct.append.read(iprot);
+ struct.setAppendIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, append_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.append != null) {
+ oprot.writeFieldBegin(APPEND_FIELD_DESC);
+ struct.append.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class append_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_argsTupleScheme getScheme() {
+ return new append_argsTupleScheme();
+ }
+ }
+
+ private static class append_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<append_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, append_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetAppend()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetAppend()) {
+ struct.append.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, append_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.append = new TAppend();
+ struct.append.read(iprot);
+ struct.setAppendIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class append_result implements org.apache.thrift.TBase<append_result, append_result._Fields>, java.io.Serializable, Cloneable, Comparable<append_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("append_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new append_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new append_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TCell> success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(append_result.class, metaDataMap);
+ }
+
+ public append_result() {
+ }
+
+ public append_result(
+ java.util.List<TCell> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public append_result(append_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TCell> __this__success = new java.util.ArrayList<TCell>(other.success.size());
+ for (TCell other_element : other.success) {
+ __this__success.add(new TCell(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public append_result deepCopy() {
+ return new append_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TCell> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TCell elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TCell>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TCell> getSuccess() {
+ return this.success;
+ }
+
+ public append_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TCell> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public append_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TCell>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof append_result)
+ return this.equals((append_result)that);
+ return false;
+ }
+
+ public boolean equals(append_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(append_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("append_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class append_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_resultStandardScheme getScheme() {
+ return new append_resultStandardScheme();
+ }
+ }
+
+ private static class append_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<append_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, append_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list592 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TCell>(_list592.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem593;
+ for (int _i594 = 0; _i594 < _list592.size; ++_i594)
+ {
+ _elem593 = new TCell();
+ _elem593.read(iprot);
+ struct.success.add(_elem593);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, append_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TCell _iter595 : struct.success)
+ {
+ _iter595.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class append_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_resultTupleScheme getScheme() {
+ return new append_resultTupleScheme();
+ }
+ }
+
+ private static class append_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<append_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, append_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TCell _iter596 : struct.success)
+ {
+ _iter596.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, append_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list597 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TCell>(_list597.size);
+ @org.apache.thrift.annotation.Nullable TCell _elem598;
+ for (int _i599 = 0; _i599 < _list597.size; ++_i599)
+ {
+ _elem598 = new TCell();
+ _elem598.read(iprot);
+ struct.success.add(_elem598);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndPut_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_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.STRING, (short)5);
+ private static final org.apache.thrift.protocol.TField MPUT_FIELD_DESC = new org.apache.thrift.protocol.TField("mput", org.apache.thrift.protocol.TType.STRUCT, (short)6);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndPut_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndPut_argsTupleSchemeFactory();
+
+ /**
+ * name of table
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ /**
+ * row key
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * column name
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ /**
+ * the expected value for the column parameter, if not
+ * provided the check is for the non-existence of the
+ * column in question
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value; // required
+ /**
+ * mutation for the put
+ */
+ public @org.apache.thrift.annotation.Nullable Mutation mput; // required
+ /**
+ * Mutation attributes
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of table
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * row key
+ */
+ ROW((short)2, "row"),
+ /**
+ * column name
+ */
+ COLUMN((short)3, "column"),
+ /**
+ * the expected value for the column parameter, if not
+ * provided the check is for the non-existence of the
+ * column in question
+ */
+ VALUE((short)5, "value"),
+ /**
+ * mutation for the put
+ */
+ MPUT((short)6, "mput"),
+ /**
+ * Mutation attributes
+ */
+ ATTRIBUTES((short)7, "attributes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 5: // VALUE
+ return VALUE;
+ case 6: // MPUT
+ return MPUT;
+ case 7: // ATTRIBUTES
+ return ATTRIBUTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.STRING , "Text")));
+ tmpMap.put(_Fields.MPUT, new org.apache.thrift.meta_data.FieldMetaData("mput", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Mutation.class)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
+ }
+
+ public checkAndPut_args() {
+ }
+
+ public checkAndPut_args(
+ java.nio.ByteBuffer tableName,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ java.nio.ByteBuffer value,
+ Mutation mput,
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes)
+ {
+ this();
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ this.mput = mput;
+ this.attributes = attributes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndPut_args(checkAndPut_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ if (other.isSetValue()) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
+ }
+ if (other.isSetMput()) {
+ this.mput = new Mutation(other.mput);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> other_element : other.attributes.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ java.nio.ByteBuffer other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__attributes_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ java.nio.ByteBuffer __this__attributes_copy_value = org.apache.thrift.TBaseHelper.copyBinary(other_element_value);
+
+ __this__attributes.put(__this__attributes_copy_key, __this__attributes_copy_value);
+ }
+ this.attributes = __this__attributes;
+ }
+ }
+
+ public checkAndPut_args deepCopy() {
+ return new checkAndPut_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.row = null;
+ this.column = null;
+ this.value = null;
+ this.mput = null;
+ this.attributes = null;
+ }
+
+ /**
+ * name of table
+ */
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * name of table
+ */
+ public checkAndPut_args setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public checkAndPut_args setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * row key
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row key
+ */
+ public checkAndPut_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public checkAndPut_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * column name
+ */
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * column name
+ */
+ public checkAndPut_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public checkAndPut_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ /**
+ * the expected value for the column parameter, if not
+ * provided the check is for the non-existence of the
+ * column in question
+ */
+ public byte[] getValue() {
+ setValue(org.apache.thrift.TBaseHelper.rightSize(value));
+ return value == null ? null : value.array();
+ }
+
+ public java.nio.ByteBuffer bufferForValue() {
+ return org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ /**
+ * the expected value for the column parameter, if not
+ * provided the check is for the non-existence of the
+ * column in question
+ */
+ public checkAndPut_args setValue(byte[] value) {
+ this.value = value == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(value.clone());
+ return this;
+ }
+
+ public checkAndPut_args setValue(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ return this;
+ }
+
+ public void unsetValue() {
+ this.value = null;
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return this.value != null;
+ }
+
+ public void setValueIsSet(boolean value) {
+ if (!value) {
+ this.value = null;
+ }
+ }
+
+ /**
+ * mutation for the put
+ */
+ @org.apache.thrift.annotation.Nullable
+ public Mutation getMput() {
+ return this.mput;
+ }
+
+ /**
+ * mutation for the put
+ */
+ public checkAndPut_args setMput(@org.apache.thrift.annotation.Nullable Mutation mput) {
+ this.mput = mput;
+ return this;
+ }
+
+ public void unsetMput() {
+ this.mput = null;
+ }
+
+ /** Returns true if field mput is set (has been assigned a value) and false otherwise */
+ public boolean isSetMput() {
+ return this.mput != null;
+ }
+
+ public void setMputIsSet(boolean value) {
+ if (!value) {
+ this.mput = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ /**
+ * Mutation attributes
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ /**
+ * Mutation attributes
+ */
+ public checkAndPut_args setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ if (value instanceof byte[]) {
+ setValue((byte[])value);
+ } else {
+ setValue((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case MPUT:
+ if (value == null) {
+ unsetMput();
+ } else {
+ setMput((Mutation)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case VALUE:
+ return getValue();
+
+ case MPUT:
+ return getMput();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case VALUE:
+ return isSetValue();
+ case MPUT:
+ return isSetMput();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndPut_args)
+ return this.equals((checkAndPut_args)that);
+ return false;
+ }
+
+ public boolean equals(checkAndPut_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_value = true && this.isSetValue();
+ boolean that_present_value = true && that.isSetValue();
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (!this.value.equals(that.value))
+ return false;
+ }
+
+ boolean this_present_mput = true && this.isSetMput();
+ boolean that_present_mput = true && that.isSetMput();
+ if (this_present_mput || that_present_mput) {
+ if (!(this_present_mput && that_present_mput))
+ return false;
+ if (!this.mput.equals(that.mput))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetValue()) ? 131071 : 524287);
+ if (isSetValue())
+ hashCode = hashCode * 8191 + value.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetMput()) ? 131071 : 524287);
+ if (isSetMput())
+ hashCode = hashCode * 8191 + mput.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndPut_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMput(), other.isSetMput());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMput()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mput, other.mput);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndPut_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("value:");
+ if (this.value == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.value, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("mput:");
+ if (this.mput == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.mput);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (mput != null) {
+ mput.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndPut_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_argsStandardScheme getScheme() {
+ return new checkAndPut_argsStandardScheme();
+ }
+ }
+
+ private static class checkAndPut_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndPut_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // MPUT
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.mput = new Mutation();
+ struct.mput.read(iprot);
+ struct.setMputIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map600 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map600.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key601;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val602;
+ for (int _i603 = 0; _i603 < _map600.size; ++_i603)
+ {
+ _key601 = iprot.readBinary();
+ _val602 = iprot.readBinary();
+ struct.attributes.put(_key601, _val602);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ if (struct.value != null) {
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeBinary(struct.value);
+ oprot.writeFieldEnd();
+ }
+ if (struct.mput != null) {
+ oprot.writeFieldBegin(MPUT_FIELD_DESC);
+ struct.mput.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter604 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter604.getKey());
+ oprot.writeBinary(_iter604.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndPut_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_argsTupleScheme getScheme() {
+ return new checkAndPut_argsTupleScheme();
+ }
+ }
+
+ private static class checkAndPut_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndPut_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetValue()) {
+ optionals.set(3);
+ }
+ if (struct.isSetMput()) {
+ optionals.set(4);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(5);
+ }
+ oprot.writeBitSet(optionals, 6);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetValue()) {
+ oprot.writeBinary(struct.value);
+ }
+ if (struct.isSetMput()) {
+ struct.mput.write(oprot);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter605 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter605.getKey());
+ oprot.writeBinary(_iter605.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(6);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.mput = new Mutation();
+ struct.mput.read(iprot);
+ struct.setMputIsSet(true);
+ }
+ if (incoming.get(5)) {
+ {
+ org.apache.thrift.protocol.TMap _map606 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map606.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key607;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val608;
+ for (int _i609 = 0; _i609 < _map606.size; ++_i609)
+ {
+ _key607 = iprot.readBinary();
+ _val608 = iprot.readBinary();
+ struct.attributes.put(_key607, _val608);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndPut_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_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 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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndPut_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndPut_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+ public @org.apache.thrift.annotation.Nullable IllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io"),
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
+ }
+
+ public checkAndPut_result() {
+ }
+
+ public checkAndPut_result(
+ boolean success,
+ IOError io,
+ IllegalArgument ia)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndPut_result(checkAndPut_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new IllegalArgument(other.ia);
+ }
+ }
+
+ public checkAndPut_result deepCopy() {
+ return new checkAndPut_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ this.ia = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public checkAndPut_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public checkAndPut_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IllegalArgument getIa() {
+ return this.ia;
+ }
+
+ public checkAndPut_result setIa(@org.apache.thrift.annotation.Nullable IllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((IllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndPut_result)
+ return this.equals((checkAndPut_result)that);
+ return false;
+ }
+
+ public boolean equals(checkAndPut_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndPut_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndPut_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndPut_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_resultStandardScheme getScheme() {
+ return new checkAndPut_resultStandardScheme();
+ }
+ }
+
+ private static class checkAndPut_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndPut_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndPut_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_resultTupleScheme getScheme() {
+ return new checkAndPut_resultTupleScheme();
+ }
+ }
+
+ private static class checkAndPut_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndPut_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.ia = new IllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getThriftServerType_args implements org.apache.thrift.TBase<getThriftServerType_args, getThriftServerType_args._Fields>, java.io.Serializable, Cloneable, Comparable<getThriftServerType_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getThriftServerType_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getThriftServerType_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getThriftServerType_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getThriftServerType_args.class, metaDataMap);
+ }
+
+ public getThriftServerType_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getThriftServerType_args(getThriftServerType_args other) {
+ }
+
+ public getThriftServerType_args deepCopy() {
+ return new getThriftServerType_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getThriftServerType_args)
+ return this.equals((getThriftServerType_args)that);
+ return false;
+ }
+
+ public boolean equals(getThriftServerType_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getThriftServerType_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getThriftServerType_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getThriftServerType_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_argsStandardScheme getScheme() {
+ return new getThriftServerType_argsStandardScheme();
+ }
+ }
+
+ private static class getThriftServerType_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getThriftServerType_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getThriftServerType_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_argsTupleScheme getScheme() {
+ return new getThriftServerType_argsTupleScheme();
+ }
+ }
+
+ private static class getThriftServerType_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getThriftServerType_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getThriftServerType_result implements org.apache.thrift.TBase<getThriftServerType_result, getThriftServerType_result._Fields>, java.io.Serializable, Cloneable, Comparable<getThriftServerType_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getThriftServerType_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getThriftServerType_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getThriftServerType_resultTupleSchemeFactory();
+
+ /**
+ *
+ * @see TThriftServerType
+ */
+ public @org.apache.thrift.annotation.Nullable TThriftServerType success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ *
+ * @see TThriftServerType
+ */
+ SUCCESS((short)0, "success");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TThriftServerType.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getThriftServerType_result.class, metaDataMap);
+ }
+
+ public getThriftServerType_result() {
+ }
+
+ public getThriftServerType_result(
+ TThriftServerType success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getThriftServerType_result(getThriftServerType_result other) {
+ if (other.isSetSuccess()) {
+ this.success = other.success;
+ }
+ }
+
+ public getThriftServerType_result deepCopy() {
+ return new getThriftServerType_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ /**
+ *
+ * @see TThriftServerType
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TThriftServerType getSuccess() {
+ return this.success;
+ }
+
+ /**
+ *
+ * @see TThriftServerType
+ */
+ public getThriftServerType_result setSuccess(@org.apache.thrift.annotation.Nullable TThriftServerType success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TThriftServerType)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getThriftServerType_result)
+ return this.equals((getThriftServerType_result)that);
+ return false;
+ }
+
+ public boolean equals(getThriftServerType_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.getValue();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getThriftServerType_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getThriftServerType_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getThriftServerType_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_resultStandardScheme getScheme() {
+ return new getThriftServerType_resultStandardScheme();
+ }
+ }
+
+ private static class getThriftServerType_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getThriftServerType_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = org.apache.hadoop.hbase.thrift.generated.TThriftServerType.findByValue(iprot.readI32());
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success.getValue());
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getThriftServerType_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_resultTupleScheme getScheme() {
+ return new getThriftServerType_resultTupleScheme();
+ }
+ }
+
+ private static class getThriftServerType_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getThriftServerType_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success.getValue());
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = org.apache.hadoop.hbase.thrift.generated.TThriftServerType.findByValue(iprot.readI32());
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getClusterId_args implements org.apache.thrift.TBase<getClusterId_args, getClusterId_args._Fields>, java.io.Serializable, Cloneable, Comparable<getClusterId_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getClusterId_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getClusterId_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getClusterId_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getClusterId_args.class, metaDataMap);
+ }
+
+ public getClusterId_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getClusterId_args(getClusterId_args other) {
+ }
+
+ public getClusterId_args deepCopy() {
+ return new getClusterId_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getClusterId_args)
+ return this.equals((getClusterId_args)that);
+ return false;
+ }
+
+ public boolean equals(getClusterId_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getClusterId_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getClusterId_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getClusterId_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_argsStandardScheme getScheme() {
+ return new getClusterId_argsStandardScheme();
+ }
+ }
+
+ private static class getClusterId_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getClusterId_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getClusterId_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getClusterId_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getClusterId_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_argsTupleScheme getScheme() {
+ return new getClusterId_argsTupleScheme();
+ }
+ }
+
+ private static class getClusterId_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getClusterId_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getClusterId_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getClusterId_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getClusterId_result implements org.apache.thrift.TBase<getClusterId_result, getClusterId_result._Fields>, java.io.Serializable, Cloneable, Comparable<getClusterId_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getClusterId_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRING, (short)0);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getClusterId_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getClusterId_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getClusterId_result.class, metaDataMap);
+ }
+
+ public getClusterId_result() {
+ }
+
+ public getClusterId_result(
+ java.lang.String success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getClusterId_result(getClusterId_result other) {
+ if (other.isSetSuccess()) {
+ this.success = other.success;
+ }
+ }
+
+ public getClusterId_result deepCopy() {
+ return new getClusterId_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getSuccess() {
+ return this.success;
+ }
+
+ public getClusterId_result setSuccess(@org.apache.thrift.annotation.Nullable java.lang.String success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getClusterId_result)
+ return this.equals((getClusterId_result)that);
+ return false;
+ }
+
+ public boolean equals(getClusterId_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getClusterId_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getClusterId_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getClusterId_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_resultStandardScheme getScheme() {
+ return new getClusterId_resultStandardScheme();
+ }
+ }
+
+ private static class getClusterId_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getClusterId_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getClusterId_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.success = iprot.readString();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getClusterId_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeString(struct.success);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getClusterId_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_resultTupleScheme getScheme() {
+ return new getClusterId_resultTupleScheme();
+ }
+ }
+
+ private static class getClusterId_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getClusterId_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getClusterId_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ oprot.writeString(struct.success);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getClusterId_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = iprot.readString();
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class grant_args implements org.apache.thrift.TBase<grant_args, grant_args._Fields>, java.io.Serializable, Cloneable, Comparable<grant_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("grant_args");
+
+ private static final org.apache.thrift.protocol.TField INFO_FIELD_DESC = new org.apache.thrift.protocol.TField("info", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new grant_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new grant_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TAccessControlEntity info; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ INFO((short)1, "info");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // INFO
+ return INFO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.INFO, new org.apache.thrift.meta_data.FieldMetaData("info", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAccessControlEntity.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(grant_args.class, metaDataMap);
+ }
+
+ public grant_args() {
+ }
+
+ public grant_args(
+ TAccessControlEntity info)
+ {
+ this();
+ this.info = info;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public grant_args(grant_args other) {
+ if (other.isSetInfo()) {
+ this.info = new TAccessControlEntity(other.info);
+ }
+ }
+
+ public grant_args deepCopy() {
+ return new grant_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.info = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TAccessControlEntity getInfo() {
+ return this.info;
+ }
+
+ public grant_args setInfo(@org.apache.thrift.annotation.Nullable TAccessControlEntity info) {
+ this.info = info;
+ return this;
+ }
+
+ public void unsetInfo() {
+ this.info = null;
+ }
+
+ /** Returns true if field info is set (has been assigned a value) and false otherwise */
+ public boolean isSetInfo() {
+ return this.info != null;
+ }
+
+ public void setInfoIsSet(boolean value) {
+ if (!value) {
+ this.info = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case INFO:
+ if (value == null) {
+ unsetInfo();
+ } else {
+ setInfo((TAccessControlEntity)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case INFO:
+ return getInfo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case INFO:
+ return isSetInfo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof grant_args)
+ return this.equals((grant_args)that);
+ return false;
+ }
+
+ public boolean equals(grant_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_info = true && this.isSetInfo();
+ boolean that_present_info = true && that.isSetInfo();
+ if (this_present_info || that_present_info) {
+ if (!(this_present_info && that_present_info))
+ return false;
+ if (!this.info.equals(that.info))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetInfo()) ? 131071 : 524287);
+ if (isSetInfo())
+ hashCode = hashCode * 8191 + info.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(grant_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetInfo(), other.isSetInfo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetInfo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.info, other.info);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("grant_args(");
+ boolean first = true;
+
+ sb.append("info:");
+ if (this.info == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.info);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (info == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'info' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (info != null) {
+ info.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class grant_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_argsStandardScheme getScheme() {
+ return new grant_argsStandardScheme();
+ }
+ }
+
+ private static class grant_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<grant_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, grant_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // INFO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, grant_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.info != null) {
+ oprot.writeFieldBegin(INFO_FIELD_DESC);
+ struct.info.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class grant_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_argsTupleScheme getScheme() {
+ return new grant_argsTupleScheme();
+ }
+ }
+
+ private static class grant_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<grant_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, grant_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, grant_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class grant_result implements org.apache.thrift.TBase<grant_result, grant_result._Fields>, java.io.Serializable, Cloneable, Comparable<grant_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("grant_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new grant_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new grant_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(grant_result.class, metaDataMap);
+ }
+
+ public grant_result() {
+ }
+
+ public grant_result(
+ boolean success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public grant_result(grant_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public grant_result deepCopy() {
+ return new grant_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public grant_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public grant_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof grant_result)
+ return this.equals((grant_result)that);
+ return false;
+ }
+
+ public boolean equals(grant_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(grant_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("grant_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class grant_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_resultStandardScheme getScheme() {
+ return new grant_resultStandardScheme();
+ }
+ }
+
+ private static class grant_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<grant_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, grant_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, grant_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class grant_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_resultTupleScheme getScheme() {
+ return new grant_resultTupleScheme();
+ }
+ }
+
+ private static class grant_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<grant_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, grant_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, grant_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class revoke_args implements org.apache.thrift.TBase<revoke_args, revoke_args._Fields>, java.io.Serializable, Cloneable, Comparable<revoke_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("revoke_args");
+
+ private static final org.apache.thrift.protocol.TField INFO_FIELD_DESC = new org.apache.thrift.protocol.TField("info", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new revoke_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new revoke_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TAccessControlEntity info; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ INFO((short)1, "info");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // INFO
+ return INFO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.INFO, new org.apache.thrift.meta_data.FieldMetaData("info", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAccessControlEntity.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(revoke_args.class, metaDataMap);
+ }
+
+ public revoke_args() {
+ }
+
+ public revoke_args(
+ TAccessControlEntity info)
+ {
+ this();
+ this.info = info;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public revoke_args(revoke_args other) {
+ if (other.isSetInfo()) {
+ this.info = new TAccessControlEntity(other.info);
+ }
+ }
+
+ public revoke_args deepCopy() {
+ return new revoke_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.info = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TAccessControlEntity getInfo() {
+ return this.info;
+ }
+
+ public revoke_args setInfo(@org.apache.thrift.annotation.Nullable TAccessControlEntity info) {
+ this.info = info;
+ return this;
+ }
+
+ public void unsetInfo() {
+ this.info = null;
+ }
+
+ /** Returns true if field info is set (has been assigned a value) and false otherwise */
+ public boolean isSetInfo() {
+ return this.info != null;
+ }
+
+ public void setInfoIsSet(boolean value) {
+ if (!value) {
+ this.info = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case INFO:
+ if (value == null) {
+ unsetInfo();
+ } else {
+ setInfo((TAccessControlEntity)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case INFO:
+ return getInfo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case INFO:
+ return isSetInfo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof revoke_args)
+ return this.equals((revoke_args)that);
+ return false;
+ }
+
+ public boolean equals(revoke_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_info = true && this.isSetInfo();
+ boolean that_present_info = true && that.isSetInfo();
+ if (this_present_info || that_present_info) {
+ if (!(this_present_info && that_present_info))
+ return false;
+ if (!this.info.equals(that.info))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetInfo()) ? 131071 : 524287);
+ if (isSetInfo())
+ hashCode = hashCode * 8191 + info.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(revoke_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetInfo(), other.isSetInfo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetInfo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.info, other.info);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("revoke_args(");
+ boolean first = true;
+
+ sb.append("info:");
+ if (this.info == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.info);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (info == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'info' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (info != null) {
+ info.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class revoke_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_argsStandardScheme getScheme() {
+ return new revoke_argsStandardScheme();
+ }
+ }
+
+ private static class revoke_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<revoke_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, revoke_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // INFO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, revoke_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.info != null) {
+ oprot.writeFieldBegin(INFO_FIELD_DESC);
+ struct.info.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class revoke_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_argsTupleScheme getScheme() {
+ return new revoke_argsTupleScheme();
+ }
+ }
+
+ private static class revoke_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<revoke_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, revoke_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, revoke_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class revoke_result implements org.apache.thrift.TBase<revoke_result, revoke_result._Fields>, java.io.Serializable, Cloneable, Comparable<revoke_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("revoke_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new revoke_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new revoke_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable IOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(revoke_result.class, metaDataMap);
+ }
+
+ public revoke_result() {
+ }
+
+ public revoke_result(
+ boolean success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public revoke_result(revoke_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new IOError(other.io);
+ }
+ }
+
+ public revoke_result deepCopy() {
+ return new revoke_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public revoke_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public IOError getIo() {
+ return this.io;
+ }
+
+ public revoke_result setIo(@org.apache.thrift.annotation.Nullable IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof revoke_result)
+ return this.equals((revoke_result)that);
+ return false;
+ }
+
+ public boolean equals(revoke_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(revoke_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("revoke_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class revoke_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_resultStandardScheme getScheme() {
+ return new revoke_resultStandardScheme();
+ }
+ }
+
+ private static class revoke_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<revoke_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, revoke_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, revoke_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class revoke_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_resultTupleScheme getScheme() {
+ return new revoke_resultTupleScheme();
+ }
+ }
+
+ private static class revoke_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<revoke_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, revoke_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, revoke_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new IOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/IOError.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/IOError.java
new file mode 100644
index 0000000..f5f6b56
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/IOError.java
@@ -0,0 +1,480 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * An IOError exception signals that an error occurred communicating
+ * to the Hbase master or an Hbase region server. Also used to return
+ * more general Hbase error conditions.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class IOError extends org.apache.thrift.TException implements org.apache.thrift.TBase<IOError, IOError._Fields>, java.io.Serializable, Cloneable, Comparable<IOError> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("IOError");
+
+ private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField CAN_RETRY_FIELD_DESC = new org.apache.thrift.protocol.TField("canRetry", org.apache.thrift.protocol.TType.BOOL, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new IOErrorStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new IOErrorTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String message; // required
+ public boolean canRetry; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ MESSAGE((short)1, "message"),
+ CAN_RETRY((short)2, "canRetry");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // MESSAGE
+ return MESSAGE;
+ case 2: // CAN_RETRY
+ return CAN_RETRY;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __CANRETRY_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.CAN_RETRY, new org.apache.thrift.meta_data.FieldMetaData("canRetry", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(IOError.class, metaDataMap);
+ }
+
+ public IOError() {
+ }
+
+ public IOError(
+ java.lang.String message,
+ boolean canRetry)
+ {
+ this();
+ this.message = message;
+ this.canRetry = canRetry;
+ setCanRetryIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public IOError(IOError other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetMessage()) {
+ this.message = other.message;
+ }
+ this.canRetry = other.canRetry;
+ }
+
+ public IOError deepCopy() {
+ return new IOError(this);
+ }
+
+ @Override
+ public void clear() {
+ this.message = null;
+ setCanRetryIsSet(false);
+ this.canRetry = false;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getMessage() {
+ return this.message;
+ }
+
+ public IOError setMessage(@org.apache.thrift.annotation.Nullable java.lang.String message) {
+ this.message = message;
+ return this;
+ }
+
+ public void unsetMessage() {
+ this.message = null;
+ }
+
+ /** Returns true if field message is set (has been assigned a value) and false otherwise */
+ public boolean isSetMessage() {
+ return this.message != null;
+ }
+
+ public void setMessageIsSet(boolean value) {
+ if (!value) {
+ this.message = null;
+ }
+ }
+
+ public boolean isCanRetry() {
+ return this.canRetry;
+ }
+
+ public IOError setCanRetry(boolean canRetry) {
+ this.canRetry = canRetry;
+ setCanRetryIsSet(true);
+ return this;
+ }
+
+ public void unsetCanRetry() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CANRETRY_ISSET_ID);
+ }
+
+ /** Returns true if field canRetry is set (has been assigned a value) and false otherwise */
+ public boolean isSetCanRetry() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CANRETRY_ISSET_ID);
+ }
+
+ public void setCanRetryIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CANRETRY_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case MESSAGE:
+ if (value == null) {
+ unsetMessage();
+ } else {
+ setMessage((java.lang.String)value);
+ }
+ break;
+
+ case CAN_RETRY:
+ if (value == null) {
+ unsetCanRetry();
+ } else {
+ setCanRetry((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MESSAGE:
+ return getMessage();
+
+ case CAN_RETRY:
+ return isCanRetry();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case MESSAGE:
+ return isSetMessage();
+ case CAN_RETRY:
+ return isSetCanRetry();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof IOError)
+ return this.equals((IOError)that);
+ return false;
+ }
+
+ public boolean equals(IOError that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_message = true && this.isSetMessage();
+ boolean that_present_message = true && that.isSetMessage();
+ if (this_present_message || that_present_message) {
+ if (!(this_present_message && that_present_message))
+ return false;
+ if (!this.message.equals(that.message))
+ return false;
+ }
+
+ boolean this_present_canRetry = true;
+ boolean that_present_canRetry = true;
+ if (this_present_canRetry || that_present_canRetry) {
+ if (!(this_present_canRetry && that_present_canRetry))
+ return false;
+ if (this.canRetry != that.canRetry)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetMessage()) ? 131071 : 524287);
+ if (isSetMessage())
+ hashCode = hashCode * 8191 + message.hashCode();
+
+ hashCode = hashCode * 8191 + ((canRetry) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(IOError other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetMessage(), other.isSetMessage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMessage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.message, other.message);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCanRetry(), other.isSetCanRetry());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCanRetry()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.canRetry, other.canRetry);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("IOError(");
+ boolean first = true;
+
+ sb.append("message:");
+ if (this.message == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.message);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("canRetry:");
+ sb.append(this.canRetry);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class IOErrorStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public IOErrorStandardScheme getScheme() {
+ return new IOErrorStandardScheme();
+ }
+ }
+
+ private static class IOErrorStandardScheme extends org.apache.thrift.scheme.StandardScheme<IOError> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, IOError struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // MESSAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // CAN_RETRY
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.canRetry = iprot.readBool();
+ struct.setCanRetryIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, IOError struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.message != null) {
+ oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+ oprot.writeString(struct.message);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(CAN_RETRY_FIELD_DESC);
+ oprot.writeBool(struct.canRetry);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class IOErrorTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public IOErrorTupleScheme getScheme() {
+ return new IOErrorTupleScheme();
+ }
+ }
+
+ private static class IOErrorTupleScheme extends org.apache.thrift.scheme.TupleScheme<IOError> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, IOError struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetMessage()) {
+ optionals.set(0);
+ }
+ if (struct.isSetCanRetry()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetMessage()) {
+ oprot.writeString(struct.message);
+ }
+ if (struct.isSetCanRetry()) {
+ oprot.writeBool(struct.canRetry);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, IOError struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.canRetry = iprot.readBool();
+ struct.setCanRetryIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/IllegalArgument.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/IllegalArgument.java
new file mode 100644
index 0000000..a0e2e97
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/IllegalArgument.java
@@ -0,0 +1,379 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * An IllegalArgument exception indicates an illegal or invalid
+ * argument was passed into a procedure.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class IllegalArgument extends org.apache.thrift.TException implements org.apache.thrift.TBase<IllegalArgument, IllegalArgument._Fields>, java.io.Serializable, Cloneable, Comparable<IllegalArgument> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("IllegalArgument");
+
+ private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new IllegalArgumentStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new IllegalArgumentTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String message; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ MESSAGE((short)1, "message");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // MESSAGE
+ return MESSAGE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(IllegalArgument.class, metaDataMap);
+ }
+
+ public IllegalArgument() {
+ }
+
+ public IllegalArgument(
+ java.lang.String message)
+ {
+ this();
+ this.message = message;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public IllegalArgument(IllegalArgument other) {
+ if (other.isSetMessage()) {
+ this.message = other.message;
+ }
+ }
+
+ public IllegalArgument deepCopy() {
+ return new IllegalArgument(this);
+ }
+
+ @Override
+ public void clear() {
+ this.message = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getMessage() {
+ return this.message;
+ }
+
+ public IllegalArgument setMessage(@org.apache.thrift.annotation.Nullable java.lang.String message) {
+ this.message = message;
+ return this;
+ }
+
+ public void unsetMessage() {
+ this.message = null;
+ }
+
+ /** Returns true if field message is set (has been assigned a value) and false otherwise */
+ public boolean isSetMessage() {
+ return this.message != null;
+ }
+
+ public void setMessageIsSet(boolean value) {
+ if (!value) {
+ this.message = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case MESSAGE:
+ if (value == null) {
+ unsetMessage();
+ } else {
+ setMessage((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MESSAGE:
+ return getMessage();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case MESSAGE:
+ return isSetMessage();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof IllegalArgument)
+ return this.equals((IllegalArgument)that);
+ return false;
+ }
+
+ public boolean equals(IllegalArgument that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_message = true && this.isSetMessage();
+ boolean that_present_message = true && that.isSetMessage();
+ if (this_present_message || that_present_message) {
+ if (!(this_present_message && that_present_message))
+ return false;
+ if (!this.message.equals(that.message))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetMessage()) ? 131071 : 524287);
+ if (isSetMessage())
+ hashCode = hashCode * 8191 + message.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(IllegalArgument other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetMessage(), other.isSetMessage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMessage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.message, other.message);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("IllegalArgument(");
+ boolean first = true;
+
+ sb.append("message:");
+ if (this.message == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.message);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class IllegalArgumentStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public IllegalArgumentStandardScheme getScheme() {
+ return new IllegalArgumentStandardScheme();
+ }
+ }
+
+ private static class IllegalArgumentStandardScheme extends org.apache.thrift.scheme.StandardScheme<IllegalArgument> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, IllegalArgument struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // MESSAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, IllegalArgument struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.message != null) {
+ oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+ oprot.writeString(struct.message);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class IllegalArgumentTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public IllegalArgumentTupleScheme getScheme() {
+ return new IllegalArgumentTupleScheme();
+ }
+ }
+
+ private static class IllegalArgumentTupleScheme extends org.apache.thrift.scheme.TupleScheme<IllegalArgument> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, IllegalArgument struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetMessage()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetMessage()) {
+ oprot.writeString(struct.message);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, IllegalArgument struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Mutation.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Mutation.java
new file mode 100644
index 0000000..7bf919f
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/Mutation.java
@@ -0,0 +1,709 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * A Mutation object is used to either update or delete a column-value.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class Mutation implements org.apache.thrift.TBase<Mutation, Mutation._Fields>, java.io.Serializable, Cloneable, Comparable<Mutation> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Mutation");
+
+ private static final org.apache.thrift.protocol.TField IS_DELETE_FIELD_DESC = new org.apache.thrift.protocol.TField("isDelete", org.apache.thrift.protocol.TType.BOOL, (short)1);
+ 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)2);
+ private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField WRITE_TO_WAL_FIELD_DESC = new org.apache.thrift.protocol.TField("writeToWAL", org.apache.thrift.protocol.TType.BOOL, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new MutationStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new MutationTupleSchemeFactory();
+
+ public boolean isDelete; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value; // required
+ public boolean writeToWAL; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IS_DELETE((short)1, "isDelete"),
+ COLUMN((short)2, "column"),
+ VALUE((short)3, "value"),
+ WRITE_TO_WAL((short)4, "writeToWAL");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IS_DELETE
+ return IS_DELETE;
+ case 2: // COLUMN
+ return COLUMN;
+ case 3: // VALUE
+ return VALUE;
+ case 4: // WRITE_TO_WAL
+ return WRITE_TO_WAL;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __ISDELETE_ISSET_ID = 0;
+ private static final int __WRITETOWAL_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IS_DELETE, new org.apache.thrift.meta_data.FieldMetaData("isDelete", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ 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.STRING , "Text")));
+ tmpMap.put(_Fields.WRITE_TO_WAL, new org.apache.thrift.meta_data.FieldMetaData("writeToWAL", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Mutation.class, metaDataMap);
+ }
+
+ public Mutation() {
+ this.isDelete = false;
+
+ this.writeToWAL = true;
+
+ }
+
+ public Mutation(
+ boolean isDelete,
+ java.nio.ByteBuffer column,
+ java.nio.ByteBuffer value,
+ boolean writeToWAL)
+ {
+ this();
+ this.isDelete = isDelete;
+ setIsDeleteIsSet(true);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ this.writeToWAL = writeToWAL;
+ setWriteToWALIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public Mutation(Mutation other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.isDelete = other.isDelete;
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ if (other.isSetValue()) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
+ }
+ this.writeToWAL = other.writeToWAL;
+ }
+
+ public Mutation deepCopy() {
+ return new Mutation(this);
+ }
+
+ @Override
+ public void clear() {
+ this.isDelete = false;
+
+ this.column = null;
+ this.value = null;
+ this.writeToWAL = true;
+
+ }
+
+ public boolean isIsDelete() {
+ return this.isDelete;
+ }
+
+ public Mutation setIsDelete(boolean isDelete) {
+ this.isDelete = isDelete;
+ setIsDeleteIsSet(true);
+ return this;
+ }
+
+ public void unsetIsDelete() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ISDELETE_ISSET_ID);
+ }
+
+ /** Returns true if field isDelete is set (has been assigned a value) and false otherwise */
+ public boolean isSetIsDelete() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ISDELETE_ISSET_ID);
+ }
+
+ public void setIsDeleteIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ISDELETE_ISSET_ID, value);
+ }
+
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ public Mutation setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public Mutation setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ public byte[] getValue() {
+ setValue(org.apache.thrift.TBaseHelper.rightSize(value));
+ return value == null ? null : value.array();
+ }
+
+ public java.nio.ByteBuffer bufferForValue() {
+ return org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ public Mutation setValue(byte[] value) {
+ this.value = value == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(value.clone());
+ return this;
+ }
+
+ public Mutation setValue(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ return this;
+ }
+
+ public void unsetValue() {
+ this.value = null;
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return this.value != null;
+ }
+
+ public void setValueIsSet(boolean value) {
+ if (!value) {
+ this.value = null;
+ }
+ }
+
+ public boolean isWriteToWAL() {
+ return this.writeToWAL;
+ }
+
+ public Mutation setWriteToWAL(boolean writeToWAL) {
+ this.writeToWAL = writeToWAL;
+ setWriteToWALIsSet(true);
+ return this;
+ }
+
+ public void unsetWriteToWAL() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __WRITETOWAL_ISSET_ID);
+ }
+
+ /** Returns true if field writeToWAL is set (has been assigned a value) and false otherwise */
+ public boolean isSetWriteToWAL() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __WRITETOWAL_ISSET_ID);
+ }
+
+ public void setWriteToWALIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __WRITETOWAL_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IS_DELETE:
+ if (value == null) {
+ unsetIsDelete();
+ } else {
+ setIsDelete((java.lang.Boolean)value);
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ if (value instanceof byte[]) {
+ setValue((byte[])value);
+ } else {
+ setValue((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case WRITE_TO_WAL:
+ if (value == null) {
+ unsetWriteToWAL();
+ } else {
+ setWriteToWAL((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IS_DELETE:
+ return isIsDelete();
+
+ case COLUMN:
+ return getColumn();
+
+ case VALUE:
+ return getValue();
+
+ case WRITE_TO_WAL:
+ return isWriteToWAL();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IS_DELETE:
+ return isSetIsDelete();
+ case COLUMN:
+ return isSetColumn();
+ case VALUE:
+ return isSetValue();
+ case WRITE_TO_WAL:
+ return isSetWriteToWAL();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof Mutation)
+ return this.equals((Mutation)that);
+ return false;
+ }
+
+ public boolean equals(Mutation that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_isDelete = true;
+ boolean that_present_isDelete = true;
+ if (this_present_isDelete || that_present_isDelete) {
+ if (!(this_present_isDelete && that_present_isDelete))
+ return false;
+ if (this.isDelete != that.isDelete)
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_value = true && this.isSetValue();
+ boolean that_present_value = true && that.isSetValue();
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (!this.value.equals(that.value))
+ return false;
+ }
+
+ boolean this_present_writeToWAL = true;
+ boolean that_present_writeToWAL = true;
+ if (this_present_writeToWAL || that_present_writeToWAL) {
+ if (!(this_present_writeToWAL && that_present_writeToWAL))
+ return false;
+ if (this.writeToWAL != that.writeToWAL)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isDelete) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetValue()) ? 131071 : 524287);
+ if (isSetValue())
+ hashCode = hashCode * 8191 + value.hashCode();
+
+ hashCode = hashCode * 8191 + ((writeToWAL) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(Mutation other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIsDelete(), other.isSetIsDelete());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIsDelete()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.isDelete, other.isDelete);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetWriteToWAL(), other.isSetWriteToWAL());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetWriteToWAL()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.writeToWAL, other.writeToWAL);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("Mutation(");
+ boolean first = true;
+
+ sb.append("isDelete:");
+ sb.append(this.isDelete);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("value:");
+ if (this.value == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.value, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("writeToWAL:");
+ sb.append(this.writeToWAL);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class MutationStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public MutationStandardScheme getScheme() {
+ return new MutationStandardScheme();
+ }
+ }
+
+ private static class MutationStandardScheme extends org.apache.thrift.scheme.StandardScheme<Mutation> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, Mutation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IS_DELETE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.isDelete = iprot.readBool();
+ struct.setIsDeleteIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // WRITE_TO_WAL
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.writeToWAL = iprot.readBool();
+ struct.setWriteToWALIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, Mutation struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(IS_DELETE_FIELD_DESC);
+ oprot.writeBool(struct.isDelete);
+ oprot.writeFieldEnd();
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ if (struct.value != null) {
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeBinary(struct.value);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(WRITE_TO_WAL_FIELD_DESC);
+ oprot.writeBool(struct.writeToWAL);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class MutationTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public MutationTupleScheme getScheme() {
+ return new MutationTupleScheme();
+ }
+ }
+
+ private static class MutationTupleScheme extends org.apache.thrift.scheme.TupleScheme<Mutation> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, Mutation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIsDelete()) {
+ optionals.set(0);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(1);
+ }
+ if (struct.isSetValue()) {
+ optionals.set(2);
+ }
+ if (struct.isSetWriteToWAL()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetIsDelete()) {
+ oprot.writeBool(struct.isDelete);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetValue()) {
+ oprot.writeBinary(struct.value);
+ }
+ if (struct.isSetWriteToWAL()) {
+ oprot.writeBool(struct.writeToWAL);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, Mutation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.isDelete = iprot.readBool();
+ struct.setIsDeleteIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.writeToWAL = iprot.readBool();
+ struct.setWriteToWALIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TAccessControlEntity.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TAccessControlEntity.java
new file mode 100644
index 0000000..24fcb05
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TAccessControlEntity.java
@@ -0,0 +1,820 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * TAccessControlEntity for permission control
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TAccessControlEntity implements org.apache.thrift.TBase<TAccessControlEntity, TAccessControlEntity._Fields>, java.io.Serializable, Cloneable, Comparable<TAccessControlEntity> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAccessControlEntity");
+
+ private static final org.apache.thrift.protocol.TField USERNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("username", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField SCOPE_FIELD_DESC = new org.apache.thrift.protocol.TField("scope", org.apache.thrift.protocol.TType.I32, (short)2);
+ private static final org.apache.thrift.protocol.TField ACTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("actions", org.apache.thrift.protocol.TType.STRING, (short)4);
+ 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)5);
+ private static final org.apache.thrift.protocol.TField NS_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("nsName", org.apache.thrift.protocol.TType.STRING, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TAccessControlEntityStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TAccessControlEntityTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String username; // required
+ /**
+ *
+ * @see TPermissionScope
+ */
+ public @org.apache.thrift.annotation.Nullable TPermissionScope scope; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String actions; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // optional
+ public @org.apache.thrift.annotation.Nullable java.lang.String nsName; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ USERNAME((short)1, "username"),
+ /**
+ *
+ * @see TPermissionScope
+ */
+ SCOPE((short)2, "scope"),
+ ACTIONS((short)4, "actions"),
+ TABLE_NAME((short)5, "tableName"),
+ NS_NAME((short)6, "nsName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // USERNAME
+ return USERNAME;
+ case 2: // SCOPE
+ return SCOPE;
+ case 4: // ACTIONS
+ return ACTIONS;
+ case 5: // TABLE_NAME
+ return TABLE_NAME;
+ case 6: // NS_NAME
+ return NS_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.TABLE_NAME,_Fields.NS_NAME};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.USERNAME, new org.apache.thrift.meta_data.FieldMetaData("username", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.SCOPE, new org.apache.thrift.meta_data.FieldMetaData("scope", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TPermissionScope.class)));
+ tmpMap.put(_Fields.ACTIONS, new org.apache.thrift.meta_data.FieldMetaData("actions", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Bytes")));
+ tmpMap.put(_Fields.NS_NAME, new org.apache.thrift.meta_data.FieldMetaData("nsName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TAccessControlEntity.class, metaDataMap);
+ }
+
+ public TAccessControlEntity() {
+ }
+
+ public TAccessControlEntity(
+ java.lang.String username,
+ TPermissionScope scope,
+ java.lang.String actions)
+ {
+ this();
+ this.username = username;
+ this.scope = scope;
+ this.actions = actions;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TAccessControlEntity(TAccessControlEntity other) {
+ if (other.isSetUsername()) {
+ this.username = other.username;
+ }
+ if (other.isSetScope()) {
+ this.scope = other.scope;
+ }
+ if (other.isSetActions()) {
+ this.actions = other.actions;
+ }
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetNsName()) {
+ this.nsName = other.nsName;
+ }
+ }
+
+ public TAccessControlEntity deepCopy() {
+ return new TAccessControlEntity(this);
+ }
+
+ @Override
+ public void clear() {
+ this.username = null;
+ this.scope = null;
+ this.actions = null;
+ this.tableName = null;
+ this.nsName = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getUsername() {
+ return this.username;
+ }
+
+ public TAccessControlEntity setUsername(@org.apache.thrift.annotation.Nullable java.lang.String username) {
+ this.username = username;
+ return this;
+ }
+
+ public void unsetUsername() {
+ this.username = null;
+ }
+
+ /** Returns true if field username is set (has been assigned a value) and false otherwise */
+ public boolean isSetUsername() {
+ return this.username != null;
+ }
+
+ public void setUsernameIsSet(boolean value) {
+ if (!value) {
+ this.username = null;
+ }
+ }
+
+ /**
+ *
+ * @see TPermissionScope
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TPermissionScope getScope() {
+ return this.scope;
+ }
+
+ /**
+ *
+ * @see TPermissionScope
+ */
+ public TAccessControlEntity setScope(@org.apache.thrift.annotation.Nullable TPermissionScope scope) {
+ this.scope = scope;
+ return this;
+ }
+
+ public void unsetScope() {
+ this.scope = null;
+ }
+
+ /** Returns true if field scope is set (has been assigned a value) and false otherwise */
+ public boolean isSetScope() {
+ return this.scope != null;
+ }
+
+ public void setScopeIsSet(boolean value) {
+ if (!value) {
+ this.scope = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getActions() {
+ return this.actions;
+ }
+
+ public TAccessControlEntity setActions(@org.apache.thrift.annotation.Nullable java.lang.String actions) {
+ this.actions = actions;
+ return this;
+ }
+
+ public void unsetActions() {
+ this.actions = null;
+ }
+
+ /** Returns true if field actions is set (has been assigned a value) and false otherwise */
+ public boolean isSetActions() {
+ return this.actions != null;
+ }
+
+ public void setActionsIsSet(boolean value) {
+ if (!value) {
+ this.actions = null;
+ }
+ }
+
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ public TAccessControlEntity setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public TAccessControlEntity setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getNsName() {
+ return this.nsName;
+ }
+
+ public TAccessControlEntity setNsName(@org.apache.thrift.annotation.Nullable java.lang.String nsName) {
+ this.nsName = nsName;
+ return this;
+ }
+
+ public void unsetNsName() {
+ this.nsName = null;
+ }
+
+ /** Returns true if field nsName is set (has been assigned a value) and false otherwise */
+ public boolean isSetNsName() {
+ return this.nsName != null;
+ }
+
+ public void setNsNameIsSet(boolean value) {
+ if (!value) {
+ this.nsName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case USERNAME:
+ if (value == null) {
+ unsetUsername();
+ } else {
+ setUsername((java.lang.String)value);
+ }
+ break;
+
+ case SCOPE:
+ if (value == null) {
+ unsetScope();
+ } else {
+ setScope((TPermissionScope)value);
+ }
+ break;
+
+ case ACTIONS:
+ if (value == null) {
+ unsetActions();
+ } else {
+ setActions((java.lang.String)value);
+ }
+ break;
+
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case NS_NAME:
+ if (value == null) {
+ unsetNsName();
+ } else {
+ setNsName((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case USERNAME:
+ return getUsername();
+
+ case SCOPE:
+ return getScope();
+
+ case ACTIONS:
+ return getActions();
+
+ case TABLE_NAME:
+ return getTableName();
+
+ case NS_NAME:
+ return getNsName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case USERNAME:
+ return isSetUsername();
+ case SCOPE:
+ return isSetScope();
+ case ACTIONS:
+ return isSetActions();
+ case TABLE_NAME:
+ return isSetTableName();
+ case NS_NAME:
+ return isSetNsName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TAccessControlEntity)
+ return this.equals((TAccessControlEntity)that);
+ return false;
+ }
+
+ public boolean equals(TAccessControlEntity that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_username = true && this.isSetUsername();
+ boolean that_present_username = true && that.isSetUsername();
+ if (this_present_username || that_present_username) {
+ if (!(this_present_username && that_present_username))
+ return false;
+ if (!this.username.equals(that.username))
+ return false;
+ }
+
+ boolean this_present_scope = true && this.isSetScope();
+ boolean that_present_scope = true && that.isSetScope();
+ if (this_present_scope || that_present_scope) {
+ if (!(this_present_scope && that_present_scope))
+ return false;
+ if (!this.scope.equals(that.scope))
+ return false;
+ }
+
+ boolean this_present_actions = true && this.isSetActions();
+ boolean that_present_actions = true && that.isSetActions();
+ if (this_present_actions || that_present_actions) {
+ if (!(this_present_actions && that_present_actions))
+ return false;
+ if (!this.actions.equals(that.actions))
+ return false;
+ }
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_nsName = true && this.isSetNsName();
+ boolean that_present_nsName = true && that.isSetNsName();
+ if (this_present_nsName || that_present_nsName) {
+ if (!(this_present_nsName && that_present_nsName))
+ return false;
+ if (!this.nsName.equals(that.nsName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetUsername()) ? 131071 : 524287);
+ if (isSetUsername())
+ hashCode = hashCode * 8191 + username.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetScope()) ? 131071 : 524287);
+ if (isSetScope())
+ hashCode = hashCode * 8191 + scope.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetActions()) ? 131071 : 524287);
+ if (isSetActions())
+ hashCode = hashCode * 8191 + actions.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetNsName()) ? 131071 : 524287);
+ if (isSetNsName())
+ hashCode = hashCode * 8191 + nsName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TAccessControlEntity other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetUsername(), other.isSetUsername());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetUsername()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.username, other.username);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetScope(), other.isSetScope());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetScope()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scope, other.scope);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetActions(), other.isSetActions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetActions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.actions, other.actions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetNsName(), other.isSetNsName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNsName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nsName, other.nsName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TAccessControlEntity(");
+ boolean first = true;
+
+ sb.append("username:");
+ if (this.username == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.username);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("scope:");
+ if (this.scope == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.scope);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("actions:");
+ if (this.actions == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.actions);
+ }
+ first = false;
+ if (isSetTableName()) {
+ if (!first) sb.append(", ");
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ }
+ if (isSetNsName()) {
+ if (!first) sb.append(", ");
+ sb.append("nsName:");
+ if (this.nsName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.nsName);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (username == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'username' was not present! Struct: " + toString());
+ }
+ if (scope == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'scope' was not present! Struct: " + toString());
+ }
+ if (actions == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'actions' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TAccessControlEntityStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAccessControlEntityStandardScheme getScheme() {
+ return new TAccessControlEntityStandardScheme();
+ }
+ }
+
+ private static class TAccessControlEntityStandardScheme extends org.apache.thrift.scheme.StandardScheme<TAccessControlEntity> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // USERNAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.username = iprot.readString();
+ struct.setUsernameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // SCOPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.scope = org.apache.hadoop.hbase.thrift.generated.TPermissionScope.findByValue(iprot.readI32());
+ struct.setScopeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ACTIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.actions = iprot.readString();
+ struct.setActionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // NS_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.nsName = iprot.readString();
+ struct.setNsNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.username != null) {
+ oprot.writeFieldBegin(USERNAME_FIELD_DESC);
+ oprot.writeString(struct.username);
+ oprot.writeFieldEnd();
+ }
+ if (struct.scope != null) {
+ oprot.writeFieldBegin(SCOPE_FIELD_DESC);
+ oprot.writeI32(struct.scope.getValue());
+ oprot.writeFieldEnd();
+ }
+ if (struct.actions != null) {
+ oprot.writeFieldBegin(ACTIONS_FIELD_DESC);
+ oprot.writeString(struct.actions);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tableName != null) {
+ if (struct.isSetTableName()) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.nsName != null) {
+ if (struct.isSetNsName()) {
+ oprot.writeFieldBegin(NS_NAME_FIELD_DESC);
+ oprot.writeString(struct.nsName);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TAccessControlEntityTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAccessControlEntityTupleScheme getScheme() {
+ return new TAccessControlEntityTupleScheme();
+ }
+ }
+
+ private static class TAccessControlEntityTupleScheme extends org.apache.thrift.scheme.TupleScheme<TAccessControlEntity> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.username);
+ oprot.writeI32(struct.scope.getValue());
+ oprot.writeString(struct.actions);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetNsName()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetTableName()) {
+ oprot.writeBinary(struct.tableName);
+ }
+ if (struct.isSetNsName()) {
+ oprot.writeString(struct.nsName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.username = iprot.readString();
+ struct.setUsernameIsSet(true);
+ struct.scope = org.apache.hadoop.hbase.thrift.generated.TPermissionScope.findByValue(iprot.readI32());
+ struct.setScopeIsSet(true);
+ struct.actions = iprot.readString();
+ struct.setActionsIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.nsName = iprot.readString();
+ struct.setNsNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TAppend.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TAppend.java
new file mode 100644
index 0000000..3d0333e
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TAppend.java
@@ -0,0 +1,825 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * An Append object is used to specify the parameters for performing the append operation.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TAppend implements org.apache.thrift.TBase<TAppend, TAppend._Fields>, java.io.Serializable, Cloneable, Comparable<TAppend> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAppend");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", 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 VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("values", org.apache.thrift.protocol.TType.LIST, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TAppendStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TAppendTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> values; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ TABLE((short)1, "table"),
+ ROW((short)2, "row"),
+ COLUMNS((short)3, "columns"),
+ VALUES((short)4, "values");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // VALUES
+ return VALUES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", 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.VALUES, new org.apache.thrift.meta_data.FieldMetaData("values", 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"))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TAppend.class, metaDataMap);
+ }
+
+ public TAppend() {
+ }
+
+ public TAppend(
+ java.nio.ByteBuffer table,
+ java.nio.ByteBuffer row,
+ java.util.List<java.nio.ByteBuffer> columns,
+ java.util.List<java.nio.ByteBuffer> values)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.columns = columns;
+ this.values = values;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TAppend(TAppend other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetValues()) {
+ java.util.List<java.nio.ByteBuffer> __this__values = new java.util.ArrayList<java.nio.ByteBuffer>(other.values.size());
+ for (java.nio.ByteBuffer other_element : other.values) {
+ __this__values.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.values = __this__values;
+ }
+ }
+
+ public TAppend deepCopy() {
+ return new TAppend(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.row = null;
+ this.columns = null;
+ this.values = null;
+ }
+
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ public TAppend setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public TAppend setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TAppend setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TAppend setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ public TAppend setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getValuesSize() {
+ return (this.values == null) ? 0 : this.values.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getValuesIterator() {
+ return (this.values == null) ? null : this.values.iterator();
+ }
+
+ public void addToValues(java.nio.ByteBuffer elem) {
+ if (this.values == null) {
+ this.values = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.values.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getValues() {
+ return this.values;
+ }
+
+ public TAppend setValues(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> values) {
+ this.values = values;
+ return this;
+ }
+
+ public void unsetValues() {
+ this.values = null;
+ }
+
+ /** Returns true if field values is set (has been assigned a value) and false otherwise */
+ public boolean isSetValues() {
+ return this.values != null;
+ }
+
+ public void setValuesIsSet(boolean value) {
+ if (!value) {
+ this.values = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case VALUES:
+ if (value == null) {
+ unsetValues();
+ } else {
+ setValues((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case VALUES:
+ return getValues();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case VALUES:
+ return isSetValues();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TAppend)
+ return this.equals((TAppend)that);
+ return false;
+ }
+
+ public boolean equals(TAppend that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_values = true && this.isSetValues();
+ boolean that_present_values = true && that.isSetValues();
+ if (this_present_values || that_present_values) {
+ if (!(this_present_values && that_present_values))
+ return false;
+ if (!this.values.equals(that.values))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetValues()) ? 131071 : 524287);
+ if (isSetValues())
+ hashCode = hashCode * 8191 + values.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TAppend other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValues(), other.isSetValues());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValues()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.values, other.values);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TAppend(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("values:");
+ if (this.values == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.values, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TAppendStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAppendStandardScheme getScheme() {
+ return new TAppendStandardScheme();
+ }
+ }
+
+ private static class TAppendStandardScheme extends org.apache.thrift.scheme.StandardScheme<TAppend> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TAppend struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list34 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list34.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem35;
+ for (int _i36 = 0; _i36 < _list34.size; ++_i36)
+ {
+ _elem35 = iprot.readBinary();
+ struct.columns.add(_elem35);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // VALUES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list37 = iprot.readListBegin();
+ struct.values = new java.util.ArrayList<java.nio.ByteBuffer>(_list37.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem38;
+ for (int _i39 = 0; _i39 < _list37.size; ++_i39)
+ {
+ _elem38 = iprot.readBinary();
+ struct.values.add(_elem38);
+ }
+ iprot.readListEnd();
+ }
+ struct.setValuesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TAppend struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter40 : struct.columns)
+ {
+ oprot.writeBinary(_iter40);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.values != null) {
+ oprot.writeFieldBegin(VALUES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.values.size()));
+ for (java.nio.ByteBuffer _iter41 : struct.values)
+ {
+ oprot.writeBinary(_iter41);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TAppendTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAppendTupleScheme getScheme() {
+ return new TAppendTupleScheme();
+ }
+ }
+
+ private static class TAppendTupleScheme extends org.apache.thrift.scheme.TupleScheme<TAppend> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTable()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetValues()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTable()) {
+ oprot.writeBinary(struct.table);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter42 : struct.columns)
+ {
+ oprot.writeBinary(_iter42);
+ }
+ }
+ }
+ if (struct.isSetValues()) {
+ {
+ oprot.writeI32(struct.values.size());
+ for (java.nio.ByteBuffer _iter43 : struct.values)
+ {
+ oprot.writeBinary(_iter43);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list44 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list44.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem45;
+ for (int _i46 = 0; _i46 < _list44.size; ++_i46)
+ {
+ _elem45 = iprot.readBinary();
+ struct.columns.add(_elem45);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TList _list47 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.values = new java.util.ArrayList<java.nio.ByteBuffer>(_list47.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem48;
+ for (int _i49 = 0; _i49 < _list47.size; ++_i49)
+ {
+ _elem48 = iprot.readBinary();
+ struct.values.add(_elem48);
+ }
+ }
+ struct.setValuesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TCell.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TCell.java
new file mode 100644
index 0000000..fe6ccf2
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TCell.java
@@ -0,0 +1,494 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * TCell - Used to transport a cell value (byte[]) and the timestamp it was
+ * stored with together as a result for get and getRow methods. This promotes
+ * the timestamp of a cell to a first-class value, making it easy to take
+ * note of temporal data. Cell is used all the way from HStore up to HTable.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TCell implements org.apache.thrift.TBase<TCell, TCell._Fields>, java.io.Serializable, Cloneable, Comparable<TCell> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TCell");
+
+ private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)1);
+ 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)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TCellStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TCellTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value; // required
+ public long timestamp; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ VALUE((short)1, "value"),
+ TIMESTAMP((short)2, "timestamp");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // VALUE
+ return VALUE;
+ case 2: // TIMESTAMP
+ return TIMESTAMP;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.STRING , "Bytes")));
+ 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)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TCell.class, metaDataMap);
+ }
+
+ public TCell() {
+ }
+
+ public TCell(
+ java.nio.ByteBuffer value,
+ long timestamp)
+ {
+ this();
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TCell(TCell other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetValue()) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
+ }
+ this.timestamp = other.timestamp;
+ }
+
+ public TCell deepCopy() {
+ return new TCell(this);
+ }
+
+ @Override
+ public void clear() {
+ this.value = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ }
+
+ public byte[] getValue() {
+ setValue(org.apache.thrift.TBaseHelper.rightSize(value));
+ return value == null ? null : value.array();
+ }
+
+ public java.nio.ByteBuffer bufferForValue() {
+ return org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ public TCell setValue(byte[] value) {
+ this.value = value == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(value.clone());
+ return this;
+ }
+
+ public TCell setValue(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ return this;
+ }
+
+ public void unsetValue() {
+ this.value = null;
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return this.value != null;
+ }
+
+ public void setValueIsSet(boolean value) {
+ if (!value) {
+ this.value = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public TCell setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ if (value instanceof byte[]) {
+ setValue((byte[])value);
+ } else {
+ setValue((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case VALUE:
+ return getValue();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case VALUE:
+ return isSetValue();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TCell)
+ return this.equals((TCell)that);
+ return false;
+ }
+
+ public boolean equals(TCell that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_value = true && this.isSetValue();
+ boolean that_present_value = true && that.isSetValue();
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (!this.value.equals(that.value))
+ return false;
+ }
+
+ boolean this_present_timestamp = true;
+ boolean that_present_timestamp = true;
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetValue()) ? 131071 : 524287);
+ if (isSetValue())
+ hashCode = hashCode * 8191 + value.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TCell other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TCell(");
+ boolean first = true;
+
+ sb.append("value:");
+ if (this.value == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.value, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TCellStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TCellStandardScheme getScheme() {
+ return new TCellStandardScheme();
+ }
+ }
+
+ private static class TCellStandardScheme extends org.apache.thrift.scheme.StandardScheme<TCell> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TCell struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TCell struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.value != null) {
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeBinary(struct.value);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TCellTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TCellTupleScheme getScheme() {
+ return new TCellTupleScheme();
+ }
+ }
+
+ private static class TCellTupleScheme extends org.apache.thrift.scheme.TupleScheme<TCell> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TCell struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetValue()) {
+ optionals.set(0);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetValue()) {
+ oprot.writeBinary(struct.value);
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TCell struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TColumn.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TColumn.java
new file mode 100644
index 0000000..8f48610
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TColumn.java
@@ -0,0 +1,501 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Holds column name and the cell.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TColumn implements org.apache.thrift.TBase<TColumn, TColumn._Fields>, java.io.Serializable, Cloneable, Comparable<TColumn> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumn");
+
+ private static final org.apache.thrift.protocol.TField COLUMN_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("columnName", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField CELL_FIELD_DESC = new org.apache.thrift.protocol.TField("cell", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TColumnStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TColumnTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer columnName; // required
+ public @org.apache.thrift.annotation.Nullable TCell cell; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ COLUMN_NAME((short)1, "columnName"),
+ CELL((short)2, "cell");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // COLUMN_NAME
+ return COLUMN_NAME;
+ case 2: // CELL
+ return CELL;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.COLUMN_NAME, new org.apache.thrift.meta_data.FieldMetaData("columnName", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
+ tmpMap.put(_Fields.CELL, new org.apache.thrift.meta_data.FieldMetaData("cell", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TColumn.class, metaDataMap);
+ }
+
+ public TColumn() {
+ }
+
+ public TColumn(
+ java.nio.ByteBuffer columnName,
+ TCell cell)
+ {
+ this();
+ this.columnName = org.apache.thrift.TBaseHelper.copyBinary(columnName);
+ this.cell = cell;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TColumn(TColumn other) {
+ if (other.isSetColumnName()) {
+ this.columnName = org.apache.thrift.TBaseHelper.copyBinary(other.columnName);
+ }
+ if (other.isSetCell()) {
+ this.cell = new TCell(other.cell);
+ }
+ }
+
+ public TColumn deepCopy() {
+ return new TColumn(this);
+ }
+
+ @Override
+ public void clear() {
+ this.columnName = null;
+ this.cell = null;
+ }
+
+ public byte[] getColumnName() {
+ setColumnName(org.apache.thrift.TBaseHelper.rightSize(columnName));
+ return columnName == null ? null : columnName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumnName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(columnName);
+ }
+
+ public TColumn setColumnName(byte[] columnName) {
+ this.columnName = columnName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(columnName.clone());
+ return this;
+ }
+
+ public TColumn setColumnName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer columnName) {
+ this.columnName = org.apache.thrift.TBaseHelper.copyBinary(columnName);
+ return this;
+ }
+
+ public void unsetColumnName() {
+ this.columnName = null;
+ }
+
+ /** Returns true if field columnName is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumnName() {
+ return this.columnName != null;
+ }
+
+ public void setColumnNameIsSet(boolean value) {
+ if (!value) {
+ this.columnName = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TCell getCell() {
+ return this.cell;
+ }
+
+ public TColumn setCell(@org.apache.thrift.annotation.Nullable TCell cell) {
+ this.cell = cell;
+ return this;
+ }
+
+ public void unsetCell() {
+ this.cell = null;
+ }
+
+ /** Returns true if field cell is set (has been assigned a value) and false otherwise */
+ public boolean isSetCell() {
+ return this.cell != null;
+ }
+
+ public void setCellIsSet(boolean value) {
+ if (!value) {
+ this.cell = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case COLUMN_NAME:
+ if (value == null) {
+ unsetColumnName();
+ } else {
+ if (value instanceof byte[]) {
+ setColumnName((byte[])value);
+ } else {
+ setColumnName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case CELL:
+ if (value == null) {
+ unsetCell();
+ } else {
+ setCell((TCell)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case COLUMN_NAME:
+ return getColumnName();
+
+ case CELL:
+ return getCell();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case COLUMN_NAME:
+ return isSetColumnName();
+ case CELL:
+ return isSetCell();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TColumn)
+ return this.equals((TColumn)that);
+ return false;
+ }
+
+ public boolean equals(TColumn that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_columnName = true && this.isSetColumnName();
+ boolean that_present_columnName = true && that.isSetColumnName();
+ if (this_present_columnName || that_present_columnName) {
+ if (!(this_present_columnName && that_present_columnName))
+ return false;
+ if (!this.columnName.equals(that.columnName))
+ return false;
+ }
+
+ boolean this_present_cell = true && this.isSetCell();
+ boolean that_present_cell = true && that.isSetCell();
+ if (this_present_cell || that_present_cell) {
+ if (!(this_present_cell && that_present_cell))
+ return false;
+ if (!this.cell.equals(that.cell))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetColumnName()) ? 131071 : 524287);
+ if (isSetColumnName())
+ hashCode = hashCode * 8191 + columnName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetCell()) ? 131071 : 524287);
+ if (isSetCell())
+ hashCode = hashCode * 8191 + cell.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TColumn other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetColumnName(), other.isSetColumnName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumnName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columnName, other.columnName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCell(), other.isSetCell());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCell()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cell, other.cell);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TColumn(");
+ boolean first = true;
+
+ sb.append("columnName:");
+ if (this.columnName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columnName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("cell:");
+ if (this.cell == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.cell);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (cell != null) {
+ cell.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TColumnStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnStandardScheme getScheme() {
+ return new TColumnStandardScheme();
+ }
+ }
+
+ private static class TColumnStandardScheme extends org.apache.thrift.scheme.StandardScheme<TColumn> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TColumn struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // COLUMN_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.columnName = iprot.readBinary();
+ struct.setColumnNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // CELL
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.cell = new TCell();
+ struct.cell.read(iprot);
+ struct.setCellIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TColumn struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.columnName != null) {
+ oprot.writeFieldBegin(COLUMN_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.columnName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.cell != null) {
+ oprot.writeFieldBegin(CELL_FIELD_DESC);
+ struct.cell.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TColumnTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnTupleScheme getScheme() {
+ return new TColumnTupleScheme();
+ }
+ }
+
+ private static class TColumnTupleScheme extends org.apache.thrift.scheme.TupleScheme<TColumn> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TColumn struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetColumnName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetCell()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetColumnName()) {
+ oprot.writeBinary(struct.columnName);
+ }
+ if (struct.isSetCell()) {
+ struct.cell.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TColumn struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.columnName = iprot.readBinary();
+ struct.setColumnNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.cell = new TCell();
+ struct.cell.read(iprot);
+ struct.setCellIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TIncrement.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TIncrement.java
new file mode 100644
index 0000000..ee1fdd1
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TIncrement.java
@@ -0,0 +1,728 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * For increments that are not incrementColumnValue
+ * equivalents.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TIncrement implements org.apache.thrift.TBase<TIncrement, TIncrement._Fields>, java.io.Serializable, Cloneable, Comparable<TIncrement> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIncrement");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", 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 AMMOUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("ammount", org.apache.thrift.protocol.TType.I64, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TIncrementStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TIncrementTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+ public long ammount; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ TABLE((short)1, "table"),
+ ROW((short)2, "row"),
+ COLUMN((short)3, "column"),
+ AMMOUNT((short)4, "ammount");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // ROW
+ return ROW;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // AMMOUNT
+ return AMMOUNT;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __AMMOUNT_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", 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.AMMOUNT, new org.apache.thrift.meta_data.FieldMetaData("ammount", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TIncrement.class, metaDataMap);
+ }
+
+ public TIncrement() {
+ }
+
+ public TIncrement(
+ java.nio.ByteBuffer table,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer column,
+ long ammount)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ this.ammount = ammount;
+ setAmmountIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TIncrement(TIncrement other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ this.ammount = other.ammount;
+ }
+
+ public TIncrement deepCopy() {
+ return new TIncrement(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.row = null;
+ this.column = null;
+ setAmmountIsSet(false);
+ this.ammount = 0;
+ }
+
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ public TIncrement setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public TIncrement setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TIncrement setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TIncrement setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ public TIncrement setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public TIncrement setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ public long getAmmount() {
+ return this.ammount;
+ }
+
+ public TIncrement setAmmount(long ammount) {
+ this.ammount = ammount;
+ setAmmountIsSet(true);
+ return this;
+ }
+
+ public void unsetAmmount() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __AMMOUNT_ISSET_ID);
+ }
+
+ /** Returns true if field ammount is set (has been assigned a value) and false otherwise */
+ public boolean isSetAmmount() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __AMMOUNT_ISSET_ID);
+ }
+
+ public void setAmmountIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __AMMOUNT_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case AMMOUNT:
+ if (value == null) {
+ unsetAmmount();
+ } else {
+ setAmmount((java.lang.Long)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case ROW:
+ return getRow();
+
+ case COLUMN:
+ return getColumn();
+
+ case AMMOUNT:
+ return getAmmount();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case ROW:
+ return isSetRow();
+ case COLUMN:
+ return isSetColumn();
+ case AMMOUNT:
+ return isSetAmmount();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TIncrement)
+ return this.equals((TIncrement)that);
+ return false;
+ }
+
+ public boolean equals(TIncrement that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ boolean this_present_ammount = true;
+ boolean that_present_ammount = true;
+ if (this_present_ammount || that_present_ammount) {
+ if (!(this_present_ammount && that_present_ammount))
+ return false;
+ if (this.ammount != that.ammount)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(ammount);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TIncrement other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAmmount(), other.isSetAmmount());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAmmount()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ammount, other.ammount);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TIncrement(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ammount:");
+ sb.append(this.ammount);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TIncrementStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIncrementStandardScheme getScheme() {
+ return new TIncrementStandardScheme();
+ }
+ }
+
+ private static class TIncrementStandardScheme extends org.apache.thrift.scheme.StandardScheme<TIncrement> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // AMMOUNT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.ammount = iprot.readI64();
+ struct.setAmmountIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TIncrement struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(AMMOUNT_FIELD_DESC);
+ oprot.writeI64(struct.ammount);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TIncrementTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIncrementTupleScheme getScheme() {
+ return new TIncrementTupleScheme();
+ }
+ }
+
+ private static class TIncrementTupleScheme extends org.apache.thrift.scheme.TupleScheme<TIncrement> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTable()) {
+ optionals.set(0);
+ }
+ if (struct.isSetRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumn()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAmmount()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTable()) {
+ oprot.writeBinary(struct.table);
+ }
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumn()) {
+ oprot.writeBinary(struct.column);
+ }
+ if (struct.isSetAmmount()) {
+ oprot.writeI64(struct.ammount);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.ammount = iprot.readI64();
+ struct.setAmmountIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TPermissionScope.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TPermissionScope.java
new file mode 100644
index 0000000..dc31e77
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TPermissionScope.java
@@ -0,0 +1,43 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TPermissionScope implements org.apache.thrift.TEnum {
+ TABLE(0),
+ NAMESPACE(1);
+
+ private final int value;
+
+ private TPermissionScope(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TPermissionScope findByValue(int value) {
+ switch (value) {
+ case 0:
+ return TABLE;
+ case 1:
+ return NAMESPACE;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TRegionInfo.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TRegionInfo.java
new file mode 100644
index 0000000..fdfb11a
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TRegionInfo.java
@@ -0,0 +1,1037 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * A TRegionInfo contains information about an HTable region.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TRegionInfo implements org.apache.thrift.TBase<TRegionInfo, TRegionInfo._Fields>, java.io.Serializable, Cloneable, Comparable<TRegionInfo> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TRegionInfo");
+
+ private static final org.apache.thrift.protocol.TField START_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("startKey", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField END_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("endKey", org.apache.thrift.protocol.TType.STRING, (short)2);
+ private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I64, (short)3);
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField VERSION_FIELD_DESC = new org.apache.thrift.protocol.TField("version", org.apache.thrift.protocol.TType.BYTE, (short)5);
+ private static final org.apache.thrift.protocol.TField SERVER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("serverName", org.apache.thrift.protocol.TType.STRING, (short)6);
+ private static final org.apache.thrift.protocol.TField PORT_FIELD_DESC = new org.apache.thrift.protocol.TField("port", org.apache.thrift.protocol.TType.I32, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TRegionInfoStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TRegionInfoTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startKey; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer endKey; // required
+ public long id; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer name; // required
+ public byte version; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer serverName; // required
+ public int port; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ START_KEY((short)1, "startKey"),
+ END_KEY((short)2, "endKey"),
+ ID((short)3, "id"),
+ NAME((short)4, "name"),
+ VERSION((short)5, "version"),
+ SERVER_NAME((short)6, "serverName"),
+ PORT((short)7, "port");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // START_KEY
+ return START_KEY;
+ case 2: // END_KEY
+ return END_KEY;
+ case 3: // ID
+ return ID;
+ case 4: // NAME
+ return NAME;
+ case 5: // VERSION
+ return VERSION;
+ case 6: // SERVER_NAME
+ return SERVER_NAME;
+ case 7: // PORT
+ return PORT;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __ID_ISSET_ID = 0;
+ private static final int __VERSION_ISSET_ID = 1;
+ private static final int __PORT_ISSET_ID = 2;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.START_KEY, new org.apache.thrift.meta_data.FieldMetaData("startKey", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
+ tmpMap.put(_Fields.END_KEY, new org.apache.thrift.meta_data.FieldMetaData("endKey", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
+ 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.I64)));
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
+ tmpMap.put(_Fields.VERSION, new org.apache.thrift.meta_data.FieldMetaData("version", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE)));
+ tmpMap.put(_Fields.SERVER_NAME, new org.apache.thrift.meta_data.FieldMetaData("serverName", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
+ tmpMap.put(_Fields.PORT, new org.apache.thrift.meta_data.FieldMetaData("port", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TRegionInfo.class, metaDataMap);
+ }
+
+ public TRegionInfo() {
+ }
+
+ public TRegionInfo(
+ java.nio.ByteBuffer startKey,
+ java.nio.ByteBuffer endKey,
+ long id,
+ java.nio.ByteBuffer name,
+ byte version,
+ java.nio.ByteBuffer serverName,
+ int port)
+ {
+ this();
+ this.startKey = org.apache.thrift.TBaseHelper.copyBinary(startKey);
+ this.endKey = org.apache.thrift.TBaseHelper.copyBinary(endKey);
+ this.id = id;
+ setIdIsSet(true);
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(name);
+ this.version = version;
+ setVersionIsSet(true);
+ this.serverName = org.apache.thrift.TBaseHelper.copyBinary(serverName);
+ this.port = port;
+ setPortIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TRegionInfo(TRegionInfo other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetStartKey()) {
+ this.startKey = org.apache.thrift.TBaseHelper.copyBinary(other.startKey);
+ }
+ if (other.isSetEndKey()) {
+ this.endKey = org.apache.thrift.TBaseHelper.copyBinary(other.endKey);
+ }
+ this.id = other.id;
+ if (other.isSetName()) {
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(other.name);
+ }
+ this.version = other.version;
+ if (other.isSetServerName()) {
+ this.serverName = org.apache.thrift.TBaseHelper.copyBinary(other.serverName);
+ }
+ this.port = other.port;
+ }
+
+ public TRegionInfo deepCopy() {
+ return new TRegionInfo(this);
+ }
+
+ @Override
+ public void clear() {
+ this.startKey = null;
+ this.endKey = null;
+ setIdIsSet(false);
+ this.id = 0;
+ this.name = null;
+ setVersionIsSet(false);
+ this.version = 0;
+ this.serverName = null;
+ setPortIsSet(false);
+ this.port = 0;
+ }
+
+ public byte[] getStartKey() {
+ setStartKey(org.apache.thrift.TBaseHelper.rightSize(startKey));
+ return startKey == null ? null : startKey.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStartKey() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startKey);
+ }
+
+ public TRegionInfo setStartKey(byte[] startKey) {
+ this.startKey = startKey == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startKey.clone());
+ return this;
+ }
+
+ public TRegionInfo setStartKey(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startKey) {
+ this.startKey = org.apache.thrift.TBaseHelper.copyBinary(startKey);
+ return this;
+ }
+
+ public void unsetStartKey() {
+ this.startKey = null;
+ }
+
+ /** Returns true if field startKey is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartKey() {
+ return this.startKey != null;
+ }
+
+ public void setStartKeyIsSet(boolean value) {
+ if (!value) {
+ this.startKey = null;
+ }
+ }
+
+ public byte[] getEndKey() {
+ setEndKey(org.apache.thrift.TBaseHelper.rightSize(endKey));
+ return endKey == null ? null : endKey.array();
+ }
+
+ public java.nio.ByteBuffer bufferForEndKey() {
+ return org.apache.thrift.TBaseHelper.copyBinary(endKey);
+ }
+
+ public TRegionInfo setEndKey(byte[] endKey) {
+ this.endKey = endKey == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(endKey.clone());
+ return this;
+ }
+
+ public TRegionInfo setEndKey(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer endKey) {
+ this.endKey = org.apache.thrift.TBaseHelper.copyBinary(endKey);
+ return this;
+ }
+
+ public void unsetEndKey() {
+ this.endKey = null;
+ }
+
+ /** Returns true if field endKey is set (has been assigned a value) and false otherwise */
+ public boolean isSetEndKey() {
+ return this.endKey != null;
+ }
+
+ public void setEndKeyIsSet(boolean value) {
+ if (!value) {
+ this.endKey = null;
+ }
+ }
+
+ public long getId() {
+ return this.id;
+ }
+
+ public TRegionInfo setId(long id) {
+ this.id = id;
+ setIdIsSet(true);
+ return this;
+ }
+
+ public void unsetId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ /** Returns true if field id is set (has been assigned a value) and false otherwise */
+ public boolean isSetId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ID_ISSET_ID);
+ }
+
+ public void setIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ID_ISSET_ID, value);
+ }
+
+ public byte[] getName() {
+ setName(org.apache.thrift.TBaseHelper.rightSize(name));
+ return name == null ? null : name.array();
+ }
+
+ public java.nio.ByteBuffer bufferForName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(name);
+ }
+
+ public TRegionInfo setName(byte[] name) {
+ this.name = name == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(name.clone());
+ return this;
+ }
+
+ public TRegionInfo setName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer name) {
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(name);
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public byte getVersion() {
+ return this.version;
+ }
+
+ public TRegionInfo setVersion(byte version) {
+ this.version = version;
+ setVersionIsSet(true);
+ return this;
+ }
+
+ public void unsetVersion() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __VERSION_ISSET_ID);
+ }
+
+ /** Returns true if field version is set (has been assigned a value) and false otherwise */
+ public boolean isSetVersion() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __VERSION_ISSET_ID);
+ }
+
+ public void setVersionIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __VERSION_ISSET_ID, value);
+ }
+
+ public byte[] getServerName() {
+ setServerName(org.apache.thrift.TBaseHelper.rightSize(serverName));
+ return serverName == null ? null : serverName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForServerName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(serverName);
+ }
+
+ public TRegionInfo setServerName(byte[] serverName) {
+ this.serverName = serverName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(serverName.clone());
+ return this;
+ }
+
+ public TRegionInfo setServerName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer serverName) {
+ this.serverName = org.apache.thrift.TBaseHelper.copyBinary(serverName);
+ return this;
+ }
+
+ public void unsetServerName() {
+ this.serverName = null;
+ }
+
+ /** Returns true if field serverName is set (has been assigned a value) and false otherwise */
+ public boolean isSetServerName() {
+ return this.serverName != null;
+ }
+
+ public void setServerNameIsSet(boolean value) {
+ if (!value) {
+ this.serverName = null;
+ }
+ }
+
+ public int getPort() {
+ return this.port;
+ }
+
+ public TRegionInfo setPort(int port) {
+ this.port = port;
+ setPortIsSet(true);
+ return this;
+ }
+
+ public void unsetPort() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PORT_ISSET_ID);
+ }
+
+ /** Returns true if field port is set (has been assigned a value) and false otherwise */
+ public boolean isSetPort() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PORT_ISSET_ID);
+ }
+
+ public void setPortIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PORT_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case START_KEY:
+ if (value == null) {
+ unsetStartKey();
+ } else {
+ if (value instanceof byte[]) {
+ setStartKey((byte[])value);
+ } else {
+ setStartKey((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case END_KEY:
+ if (value == null) {
+ unsetEndKey();
+ } else {
+ if (value instanceof byte[]) {
+ setEndKey((byte[])value);
+ } else {
+ setEndKey((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ID:
+ if (value == null) {
+ unsetId();
+ } else {
+ setId((java.lang.Long)value);
+ }
+ break;
+
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ if (value instanceof byte[]) {
+ setName((byte[])value);
+ } else {
+ setName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case VERSION:
+ if (value == null) {
+ unsetVersion();
+ } else {
+ setVersion((java.lang.Byte)value);
+ }
+ break;
+
+ case SERVER_NAME:
+ if (value == null) {
+ unsetServerName();
+ } else {
+ if (value instanceof byte[]) {
+ setServerName((byte[])value);
+ } else {
+ setServerName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case PORT:
+ if (value == null) {
+ unsetPort();
+ } else {
+ setPort((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case START_KEY:
+ return getStartKey();
+
+ case END_KEY:
+ return getEndKey();
+
+ case ID:
+ return getId();
+
+ case NAME:
+ return getName();
+
+ case VERSION:
+ return getVersion();
+
+ case SERVER_NAME:
+ return getServerName();
+
+ case PORT:
+ return getPort();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case START_KEY:
+ return isSetStartKey();
+ case END_KEY:
+ return isSetEndKey();
+ case ID:
+ return isSetId();
+ case NAME:
+ return isSetName();
+ case VERSION:
+ return isSetVersion();
+ case SERVER_NAME:
+ return isSetServerName();
+ case PORT:
+ return isSetPort();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TRegionInfo)
+ return this.equals((TRegionInfo)that);
+ return false;
+ }
+
+ public boolean equals(TRegionInfo that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_startKey = true && this.isSetStartKey();
+ boolean that_present_startKey = true && that.isSetStartKey();
+ if (this_present_startKey || that_present_startKey) {
+ if (!(this_present_startKey && that_present_startKey))
+ return false;
+ if (!this.startKey.equals(that.startKey))
+ return false;
+ }
+
+ boolean this_present_endKey = true && this.isSetEndKey();
+ boolean that_present_endKey = true && that.isSetEndKey();
+ if (this_present_endKey || that_present_endKey) {
+ if (!(this_present_endKey && that_present_endKey))
+ return false;
+ if (!this.endKey.equals(that.endKey))
+ return false;
+ }
+
+ boolean this_present_id = true;
+ boolean that_present_id = true;
+ if (this_present_id || that_present_id) {
+ if (!(this_present_id && that_present_id))
+ return false;
+ if (this.id != that.id)
+ return false;
+ }
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ boolean this_present_version = true;
+ boolean that_present_version = true;
+ if (this_present_version || that_present_version) {
+ if (!(this_present_version && that_present_version))
+ return false;
+ if (this.version != that.version)
+ return false;
+ }
+
+ boolean this_present_serverName = true && this.isSetServerName();
+ boolean that_present_serverName = true && that.isSetServerName();
+ if (this_present_serverName || that_present_serverName) {
+ if (!(this_present_serverName && that_present_serverName))
+ return false;
+ if (!this.serverName.equals(that.serverName))
+ return false;
+ }
+
+ boolean this_present_port = true;
+ boolean that_present_port = true;
+ if (this_present_port || that_present_port) {
+ if (!(this_present_port && that_present_port))
+ return false;
+ if (this.port != that.port)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetStartKey()) ? 131071 : 524287);
+ if (isSetStartKey())
+ hashCode = hashCode * 8191 + startKey.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetEndKey()) ? 131071 : 524287);
+ if (isSetEndKey())
+ hashCode = hashCode * 8191 + endKey.hashCode();
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(id);
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ hashCode = hashCode * 8191 + (int) (version);
+
+ hashCode = hashCode * 8191 + ((isSetServerName()) ? 131071 : 524287);
+ if (isSetServerName())
+ hashCode = hashCode * 8191 + serverName.hashCode();
+
+ hashCode = hashCode * 8191 + port;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TRegionInfo other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetStartKey(), other.isSetStartKey());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartKey()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startKey, other.startKey);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetEndKey(), other.isSetEndKey());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetEndKey()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.endKey, other.endKey);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetId(), other.isSetId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, other.id);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetVersion(), other.isSetVersion());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetVersion()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.version, other.version);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetServerName(), other.isSetServerName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetServerName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverName, other.serverName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetPort(), other.isSetPort());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetPort()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.port, other.port);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TRegionInfo(");
+ boolean first = true;
+
+ sb.append("startKey:");
+ if (this.startKey == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startKey, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("endKey:");
+ if (this.endKey == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.endKey, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("id:");
+ sb.append(this.id);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.name, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("version:");
+ sb.append(this.version);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("serverName:");
+ if (this.serverName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.serverName, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("port:");
+ sb.append(this.port);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TRegionInfoStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TRegionInfoStandardScheme getScheme() {
+ return new TRegionInfoStandardScheme();
+ }
+ }
+
+ private static class TRegionInfoStandardScheme extends org.apache.thrift.scheme.StandardScheme<TRegionInfo> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TRegionInfo struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // START_KEY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startKey = iprot.readBinary();
+ struct.setStartKeyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // END_KEY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.endKey = iprot.readBinary();
+ struct.setEndKeyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.id = iprot.readI64();
+ struct.setIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readBinary();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // VERSION
+ if (schemeField.type == org.apache.thrift.protocol.TType.BYTE) {
+ struct.version = iprot.readByte();
+ struct.setVersionIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // SERVER_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.serverName = iprot.readBinary();
+ struct.setServerNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // PORT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.port = iprot.readI32();
+ struct.setPortIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TRegionInfo struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.startKey != null) {
+ oprot.writeFieldBegin(START_KEY_FIELD_DESC);
+ oprot.writeBinary(struct.startKey);
+ oprot.writeFieldEnd();
+ }
+ if (struct.endKey != null) {
+ oprot.writeFieldBegin(END_KEY_FIELD_DESC);
+ oprot.writeBinary(struct.endKey);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(ID_FIELD_DESC);
+ oprot.writeI64(struct.id);
+ oprot.writeFieldEnd();
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeBinary(struct.name);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(VERSION_FIELD_DESC);
+ oprot.writeByte(struct.version);
+ oprot.writeFieldEnd();
+ if (struct.serverName != null) {
+ oprot.writeFieldBegin(SERVER_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.serverName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(PORT_FIELD_DESC);
+ oprot.writeI32(struct.port);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TRegionInfoTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TRegionInfoTupleScheme getScheme() {
+ return new TRegionInfoTupleScheme();
+ }
+ }
+
+ private static class TRegionInfoTupleScheme extends org.apache.thrift.scheme.TupleScheme<TRegionInfo> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TRegionInfo struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetStartKey()) {
+ optionals.set(0);
+ }
+ if (struct.isSetEndKey()) {
+ optionals.set(1);
+ }
+ if (struct.isSetId()) {
+ optionals.set(2);
+ }
+ if (struct.isSetName()) {
+ optionals.set(3);
+ }
+ if (struct.isSetVersion()) {
+ optionals.set(4);
+ }
+ if (struct.isSetServerName()) {
+ optionals.set(5);
+ }
+ if (struct.isSetPort()) {
+ optionals.set(6);
+ }
+ oprot.writeBitSet(optionals, 7);
+ if (struct.isSetStartKey()) {
+ oprot.writeBinary(struct.startKey);
+ }
+ if (struct.isSetEndKey()) {
+ oprot.writeBinary(struct.endKey);
+ }
+ if (struct.isSetId()) {
+ oprot.writeI64(struct.id);
+ }
+ if (struct.isSetName()) {
+ oprot.writeBinary(struct.name);
+ }
+ if (struct.isSetVersion()) {
+ oprot.writeByte(struct.version);
+ }
+ if (struct.isSetServerName()) {
+ oprot.writeBinary(struct.serverName);
+ }
+ if (struct.isSetPort()) {
+ oprot.writeI32(struct.port);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TRegionInfo struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(7);
+ if (incoming.get(0)) {
+ struct.startKey = iprot.readBinary();
+ struct.setStartKeyIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.endKey = iprot.readBinary();
+ struct.setEndKeyIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.id = iprot.readI64();
+ struct.setIdIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.name = iprot.readBinary();
+ struct.setNameIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.version = iprot.readByte();
+ struct.setVersionIsSet(true);
+ }
+ if (incoming.get(5)) {
+ struct.serverName = iprot.readBinary();
+ struct.setServerNameIsSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.port = iprot.readI32();
+ struct.setPortIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TRowResult.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TRowResult.java
new file mode 100644
index 0000000..d395911
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TRowResult.java
@@ -0,0 +1,726 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Holds row name and then a map of columns to cells.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TRowResult implements org.apache.thrift.TBase<TRowResult, TRowResult._Fields>, java.io.Serializable, Cloneable, Comparable<TRowResult> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TRowResult");
+
+ 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)1);
+ private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.MAP, (short)2);
+ private static final org.apache.thrift.protocol.TField SORTED_COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("sortedColumns", org.apache.thrift.protocol.TType.LIST, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TRowResultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TRowResultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,TCell> columns; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumn> sortedColumns; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ COLUMNS((short)2, "columns"),
+ SORTED_COLUMNS((short)3, "sortedColumns");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // COLUMNS
+ return COLUMNS;
+ case 3: // SORTED_COLUMNS
+ return SORTED_COLUMNS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.COLUMNS,_Fields.SORTED_COLUMNS};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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.OPTIONAL,
+ 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, TCell.class))));
+ tmpMap.put(_Fields.SORTED_COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("sortedColumns", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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, TColumn.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TRowResult.class, metaDataMap);
+ }
+
+ public TRowResult() {
+ }
+
+ public TRowResult(
+ java.nio.ByteBuffer row)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TRowResult(TRowResult other) {
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.Map<java.nio.ByteBuffer,TCell> __this__columns = new java.util.HashMap<java.nio.ByteBuffer,TCell>(other.columns.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, TCell> other_element : other.columns.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ TCell other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__columns_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ TCell __this__columns_copy_value = new TCell(other_element_value);
+
+ __this__columns.put(__this__columns_copy_key, __this__columns_copy_value);
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetSortedColumns()) {
+ java.util.List<TColumn> __this__sortedColumns = new java.util.ArrayList<TColumn>(other.sortedColumns.size());
+ for (TColumn other_element : other.sortedColumns) {
+ __this__sortedColumns.add(new TColumn(other_element));
+ }
+ this.sortedColumns = __this__sortedColumns;
+ }
+ }
+
+ public TRowResult deepCopy() {
+ return new TRowResult(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.columns = null;
+ this.sortedColumns = null;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TRowResult setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TRowResult setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ public void putToColumns(java.nio.ByteBuffer key, TCell val) {
+ if (this.columns == null) {
+ this.columns = new java.util.HashMap<java.nio.ByteBuffer,TCell>();
+ }
+ this.columns.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,TCell> getColumns() {
+ return this.columns;
+ }
+
+ public TRowResult setColumns(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,TCell> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getSortedColumnsSize() {
+ return (this.sortedColumns == null) ? 0 : this.sortedColumns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumn> getSortedColumnsIterator() {
+ return (this.sortedColumns == null) ? null : this.sortedColumns.iterator();
+ }
+
+ public void addToSortedColumns(TColumn elem) {
+ if (this.sortedColumns == null) {
+ this.sortedColumns = new java.util.ArrayList<TColumn>();
+ }
+ this.sortedColumns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumn> getSortedColumns() {
+ return this.sortedColumns;
+ }
+
+ public TRowResult setSortedColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumn> sortedColumns) {
+ this.sortedColumns = sortedColumns;
+ return this;
+ }
+
+ public void unsetSortedColumns() {
+ this.sortedColumns = null;
+ }
+
+ /** Returns true if field sortedColumns is set (has been assigned a value) and false otherwise */
+ public boolean isSetSortedColumns() {
+ return this.sortedColumns != null;
+ }
+
+ public void setSortedColumnsIsSet(boolean value) {
+ if (!value) {
+ this.sortedColumns = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.Map<java.nio.ByteBuffer,TCell>)value);
+ }
+ break;
+
+ case SORTED_COLUMNS:
+ if (value == null) {
+ unsetSortedColumns();
+ } else {
+ setSortedColumns((java.util.List<TColumn>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case SORTED_COLUMNS:
+ return getSortedColumns();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case SORTED_COLUMNS:
+ return isSetSortedColumns();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TRowResult)
+ return this.equals((TRowResult)that);
+ return false;
+ }
+
+ public boolean equals(TRowResult that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_sortedColumns = true && this.isSetSortedColumns();
+ boolean that_present_sortedColumns = true && that.isSetSortedColumns();
+ if (this_present_sortedColumns || that_present_sortedColumns) {
+ if (!(this_present_sortedColumns && that_present_sortedColumns))
+ return false;
+ if (!this.sortedColumns.equals(that.sortedColumns))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetSortedColumns()) ? 131071 : 524287);
+ if (isSetSortedColumns())
+ hashCode = hashCode * 8191 + sortedColumns.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TRowResult other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetSortedColumns(), other.isSetSortedColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSortedColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sortedColumns, other.sortedColumns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TRowResult(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (isSetColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columns);
+ }
+ first = false;
+ }
+ if (isSetSortedColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("sortedColumns:");
+ if (this.sortedColumns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.sortedColumns);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TRowResultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TRowResultStandardScheme getScheme() {
+ return new TRowResultStandardScheme();
+ }
+ }
+
+ private static class TRowResultStandardScheme extends org.apache.thrift.scheme.StandardScheme<TRowResult> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TRowResult struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map8 = iprot.readMapBegin();
+ struct.columns = new java.util.HashMap<java.nio.ByteBuffer,TCell>(2*_map8.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key9;
+ @org.apache.thrift.annotation.Nullable TCell _val10;
+ for (int _i11 = 0; _i11 < _map8.size; ++_i11)
+ {
+ _key9 = iprot.readBinary();
+ _val10 = new TCell();
+ _val10.read(iprot);
+ struct.columns.put(_key9, _val10);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // SORTED_COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list12 = iprot.readListBegin();
+ struct.sortedColumns = new java.util.ArrayList<TColumn>(_list12.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem13;
+ for (int _i14 = 0; _i14 < _list12.size; ++_i14)
+ {
+ _elem13 = new TColumn();
+ _elem13.read(iprot);
+ struct.sortedColumns.add(_elem13);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSortedColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TRowResult struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ if (struct.isSetColumns()) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, TCell> _iter15 : struct.columns.entrySet())
+ {
+ oprot.writeBinary(_iter15.getKey());
+ _iter15.getValue().write(oprot);
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.sortedColumns != null) {
+ if (struct.isSetSortedColumns()) {
+ oprot.writeFieldBegin(SORTED_COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.sortedColumns.size()));
+ for (TColumn _iter16 : struct.sortedColumns)
+ {
+ _iter16.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TRowResultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TRowResultTupleScheme getScheme() {
+ return new TRowResultTupleScheme();
+ }
+ }
+
+ private static class TRowResultTupleScheme extends org.apache.thrift.scheme.TupleScheme<TRowResult> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TRowResult struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRow()) {
+ optionals.set(0);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(1);
+ }
+ if (struct.isSetSortedColumns()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, TCell> _iter17 : struct.columns.entrySet())
+ {
+ oprot.writeBinary(_iter17.getKey());
+ _iter17.getValue().write(oprot);
+ }
+ }
+ }
+ if (struct.isSetSortedColumns()) {
+ {
+ oprot.writeI32(struct.sortedColumns.size());
+ for (TColumn _iter18 : struct.sortedColumns)
+ {
+ _iter18.write(oprot);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TRowResult struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TMap _map19 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT);
+ struct.columns = new java.util.HashMap<java.nio.ByteBuffer,TCell>(2*_map19.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key20;
+ @org.apache.thrift.annotation.Nullable TCell _val21;
+ for (int _i22 = 0; _i22 < _map19.size; ++_i22)
+ {
+ _key20 = iprot.readBinary();
+ _val21 = new TCell();
+ _val21.read(iprot);
+ struct.columns.put(_key20, _val21);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list23 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.sortedColumns = new java.util.ArrayList<TColumn>(_list23.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem24;
+ for (int _i25 = 0; _i25 < _list23.size; ++_i25)
+ {
+ _elem24 = new TColumn();
+ _elem24.read(iprot);
+ struct.sortedColumns.add(_elem24);
+ }
+ }
+ struct.setSortedColumnsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TScan.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TScan.java
new file mode 100644
index 0000000..ec486ac
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TScan.java
@@ -0,0 +1,1387 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * A Scan object is used to specify scanner parameters when opening a scanner.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TScan implements org.apache.thrift.TBase<TScan, TScan._Fields>, java.io.Serializable, Cloneable, Comparable<TScan> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.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 org.apache.thrift.protocol.TField FILTER_STRING_FIELD_DESC = new org.apache.thrift.protocol.TField("filterString", org.apache.thrift.protocol.TType.STRING, (short)6);
+ private static final org.apache.thrift.protocol.TField BATCH_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("batchSize", org.apache.thrift.protocol.TType.I32, (short)7);
+ private static final org.apache.thrift.protocol.TField SORT_COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("sortColumns", org.apache.thrift.protocol.TType.BOOL, (short)8);
+ private static final org.apache.thrift.protocol.TField REVERSED_FIELD_DESC = new org.apache.thrift.protocol.TField("reversed", org.apache.thrift.protocol.TType.BOOL, (short)9);
+ private static final org.apache.thrift.protocol.TField CACHE_BLOCKS_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheBlocks", org.apache.thrift.protocol.TType.BOOL, (short)10);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TScanStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TScanTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow; // optional
+ public long timestamp; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns; // optional
+ public int caching; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString; // optional
+ public int batchSize; // optional
+ public boolean sortColumns; // optional
+ public boolean reversed; // optional
+ public boolean cacheBlocks; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ START_ROW((short)1, "startRow"),
+ STOP_ROW((short)2, "stopRow"),
+ TIMESTAMP((short)3, "timestamp"),
+ COLUMNS((short)4, "columns"),
+ CACHING((short)5, "caching"),
+ FILTER_STRING((short)6, "filterString"),
+ BATCH_SIZE((short)7, "batchSize"),
+ SORT_COLUMNS((short)8, "sortColumns"),
+ REVERSED((short)9, "reversed"),
+ CACHE_BLOCKS((short)10, "cacheBlocks");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // START_ROW
+ return START_ROW;
+ case 2: // STOP_ROW
+ return STOP_ROW;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 4: // COLUMNS
+ return COLUMNS;
+ case 5: // CACHING
+ return CACHING;
+ case 6: // FILTER_STRING
+ return FILTER_STRING;
+ case 7: // BATCH_SIZE
+ return BATCH_SIZE;
+ case 8: // SORT_COLUMNS
+ return SORT_COLUMNS;
+ case 9: // REVERSED
+ return REVERSED;
+ case 10: // CACHE_BLOCKS
+ return CACHE_BLOCKS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private static final int __CACHING_ISSET_ID = 1;
+ private static final int __BATCHSIZE_ISSET_ID = 2;
+ private static final int __SORTCOLUMNS_ISSET_ID = 3;
+ private static final int __REVERSED_ISSET_ID = 4;
+ private static final int __CACHEBLOCKS_ISSET_ID = 5;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.START_ROW,_Fields.STOP_ROW,_Fields.TIMESTAMP,_Fields.COLUMNS,_Fields.CACHING,_Fields.FILTER_STRING,_Fields.BATCH_SIZE,_Fields.SORT_COLUMNS,_Fields.REVERSED,_Fields.CACHE_BLOCKS};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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)));
+ tmpMap.put(_Fields.FILTER_STRING, new org.apache.thrift.meta_data.FieldMetaData("filterString", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
+ tmpMap.put(_Fields.BATCH_SIZE, new org.apache.thrift.meta_data.FieldMetaData("batchSize", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.SORT_COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("sortColumns", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.REVERSED, new org.apache.thrift.meta_data.FieldMetaData("reversed", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.CACHE_BLOCKS, new org.apache.thrift.meta_data.FieldMetaData("cacheBlocks", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TScan.class, metaDataMap);
+ }
+
+ public TScan() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TScan(TScan other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetStartRow()) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
+ }
+ if (other.isSetStopRow()) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(other.stopRow);
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetColumns()) {
+ java.util.List<java.nio.ByteBuffer> __this__columns = new java.util.ArrayList<java.nio.ByteBuffer>(other.columns.size());
+ for (java.nio.ByteBuffer other_element : other.columns) {
+ __this__columns.add(org.apache.thrift.TBaseHelper.copyBinary(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.caching = other.caching;
+ if (other.isSetFilterString()) {
+ this.filterString = org.apache.thrift.TBaseHelper.copyBinary(other.filterString);
+ }
+ this.batchSize = other.batchSize;
+ this.sortColumns = other.sortColumns;
+ this.reversed = other.reversed;
+ this.cacheBlocks = other.cacheBlocks;
+ }
+
+ public TScan deepCopy() {
+ return new TScan(this);
+ }
+
+ @Override
+ public void clear() {
+ this.startRow = null;
+ this.stopRow = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.columns = null;
+ setCachingIsSet(false);
+ this.caching = 0;
+ this.filterString = null;
+ setBatchSizeIsSet(false);
+ this.batchSize = 0;
+ setSortColumnsIsSet(false);
+ this.sortColumns = false;
+ setReversedIsSet(false);
+ this.reversed = false;
+ setCacheBlocksIsSet(false);
+ this.cacheBlocks = false;
+ }
+
+ public byte[] getStartRow() {
+ setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow));
+ return startRow == null ? null : startRow.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStartRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ }
+
+ public TScan setStartRow(byte[] startRow) {
+ this.startRow = startRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startRow.clone());
+ return this;
+ }
+
+ public TScan setStartRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ return this;
+ }
+
+ public void unsetStartRow() {
+ this.startRow = null;
+ }
+
+ /** Returns true if field startRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartRow() {
+ return this.startRow != null;
+ }
+
+ public void setStartRowIsSet(boolean value) {
+ if (!value) {
+ this.startRow = null;
+ }
+ }
+
+ public byte[] getStopRow() {
+ setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow));
+ return stopRow == null ? null : stopRow.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStopRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ }
+
+ public TScan setStopRow(byte[] stopRow) {
+ this.stopRow = stopRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(stopRow.clone());
+ return this;
+ }
+
+ public TScan setStopRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ return this;
+ }
+
+ public void unsetStopRow() {
+ this.stopRow = null;
+ }
+
+ /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStopRow() {
+ return this.stopRow != null;
+ }
+
+ public void setStopRowIsSet(boolean value) {
+ if (!value) {
+ this.stopRow = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public TScan setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(java.nio.ByteBuffer elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getColumns() {
+ return this.columns;
+ }
+
+ public TScan setColumns(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getCaching() {
+ return this.caching;
+ }
+
+ public TScan setCaching(int caching) {
+ this.caching = caching;
+ setCachingIsSet(true);
+ return this;
+ }
+
+ public void unsetCaching() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHING_ISSET_ID);
+ }
+
+ /** Returns true if field caching is set (has been assigned a value) and false otherwise */
+ public boolean isSetCaching() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHING_ISSET_ID);
+ }
+
+ public void setCachingIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHING_ISSET_ID, value);
+ }
+
+ public byte[] getFilterString() {
+ setFilterString(org.apache.thrift.TBaseHelper.rightSize(filterString));
+ return filterString == null ? null : filterString.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFilterString() {
+ return org.apache.thrift.TBaseHelper.copyBinary(filterString);
+ }
+
+ public TScan setFilterString(byte[] filterString) {
+ this.filterString = filterString == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(filterString.clone());
+ return this;
+ }
+
+ public TScan setFilterString(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString) {
+ this.filterString = org.apache.thrift.TBaseHelper.copyBinary(filterString);
+ return this;
+ }
+
+ public void unsetFilterString() {
+ this.filterString = null;
+ }
+
+ /** Returns true if field filterString is set (has been assigned a value) and false otherwise */
+ public boolean isSetFilterString() {
+ return this.filterString != null;
+ }
+
+ public void setFilterStringIsSet(boolean value) {
+ if (!value) {
+ this.filterString = null;
+ }
+ }
+
+ public int getBatchSize() {
+ return this.batchSize;
+ }
+
+ public TScan setBatchSize(int batchSize) {
+ this.batchSize = batchSize;
+ setBatchSizeIsSet(true);
+ return this;
+ }
+
+ public void unsetBatchSize() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BATCHSIZE_ISSET_ID);
+ }
+
+ /** Returns true if field batchSize is set (has been assigned a value) and false otherwise */
+ public boolean isSetBatchSize() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BATCHSIZE_ISSET_ID);
+ }
+
+ public void setBatchSizeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BATCHSIZE_ISSET_ID, value);
+ }
+
+ public boolean isSortColumns() {
+ return this.sortColumns;
+ }
+
+ public TScan setSortColumns(boolean sortColumns) {
+ this.sortColumns = sortColumns;
+ setSortColumnsIsSet(true);
+ return this;
+ }
+
+ public void unsetSortColumns() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SORTCOLUMNS_ISSET_ID);
+ }
+
+ /** Returns true if field sortColumns is set (has been assigned a value) and false otherwise */
+ public boolean isSetSortColumns() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SORTCOLUMNS_ISSET_ID);
+ }
+
+ public void setSortColumnsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SORTCOLUMNS_ISSET_ID, value);
+ }
+
+ public boolean isReversed() {
+ return this.reversed;
+ }
+
+ public TScan setReversed(boolean reversed) {
+ this.reversed = reversed;
+ setReversedIsSet(true);
+ return this;
+ }
+
+ public void unsetReversed() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __REVERSED_ISSET_ID);
+ }
+
+ /** Returns true if field reversed is set (has been assigned a value) and false otherwise */
+ public boolean isSetReversed() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __REVERSED_ISSET_ID);
+ }
+
+ public void setReversedIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __REVERSED_ISSET_ID, value);
+ }
+
+ public boolean isCacheBlocks() {
+ return this.cacheBlocks;
+ }
+
+ public TScan setCacheBlocks(boolean cacheBlocks) {
+ this.cacheBlocks = cacheBlocks;
+ setCacheBlocksIsSet(true);
+ return this;
+ }
+
+ public void unsetCacheBlocks() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
+ }
+
+ /** Returns true if field cacheBlocks is set (has been assigned a value) and false otherwise */
+ public boolean isSetCacheBlocks() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
+ }
+
+ public void setCacheBlocksIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case START_ROW:
+ if (value == null) {
+ unsetStartRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStartRow((byte[])value);
+ } else {
+ setStartRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case STOP_ROW:
+ if (value == null) {
+ unsetStopRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStopRow((byte[])value);
+ } else {
+ setStopRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case CACHING:
+ if (value == null) {
+ unsetCaching();
+ } else {
+ setCaching((java.lang.Integer)value);
+ }
+ break;
+
+ case FILTER_STRING:
+ if (value == null) {
+ unsetFilterString();
+ } else {
+ if (value instanceof byte[]) {
+ setFilterString((byte[])value);
+ } else {
+ setFilterString((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case BATCH_SIZE:
+ if (value == null) {
+ unsetBatchSize();
+ } else {
+ setBatchSize((java.lang.Integer)value);
+ }
+ break;
+
+ case SORT_COLUMNS:
+ if (value == null) {
+ unsetSortColumns();
+ } else {
+ setSortColumns((java.lang.Boolean)value);
+ }
+ break;
+
+ case REVERSED:
+ if (value == null) {
+ unsetReversed();
+ } else {
+ setReversed((java.lang.Boolean)value);
+ }
+ break;
+
+ case CACHE_BLOCKS:
+ if (value == null) {
+ unsetCacheBlocks();
+ } else {
+ setCacheBlocks((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case START_ROW:
+ return getStartRow();
+
+ case STOP_ROW:
+ return getStopRow();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case COLUMNS:
+ return getColumns();
+
+ case CACHING:
+ return getCaching();
+
+ case FILTER_STRING:
+ return getFilterString();
+
+ case BATCH_SIZE:
+ return getBatchSize();
+
+ case SORT_COLUMNS:
+ return isSortColumns();
+
+ case REVERSED:
+ return isReversed();
+
+ case CACHE_BLOCKS:
+ return isCacheBlocks();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case START_ROW:
+ return isSetStartRow();
+ case STOP_ROW:
+ return isSetStopRow();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case COLUMNS:
+ return isSetColumns();
+ case CACHING:
+ return isSetCaching();
+ case FILTER_STRING:
+ return isSetFilterString();
+ case BATCH_SIZE:
+ return isSetBatchSize();
+ case SORT_COLUMNS:
+ return isSetSortColumns();
+ case REVERSED:
+ return isSetReversed();
+ case CACHE_BLOCKS:
+ return isSetCacheBlocks();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TScan)
+ return this.equals((TScan)that);
+ return false;
+ }
+
+ public boolean equals(TScan that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_startRow = true && this.isSetStartRow();
+ boolean that_present_startRow = true && that.isSetStartRow();
+ if (this_present_startRow || that_present_startRow) {
+ if (!(this_present_startRow && that_present_startRow))
+ return false;
+ if (!this.startRow.equals(that.startRow))
+ return false;
+ }
+
+ boolean this_present_stopRow = true && this.isSetStopRow();
+ boolean that_present_stopRow = true && that.isSetStopRow();
+ if (this_present_stopRow || that_present_stopRow) {
+ if (!(this_present_stopRow && that_present_stopRow))
+ return false;
+ if (!this.stopRow.equals(that.stopRow))
+ return false;
+ }
+
+ boolean this_present_timestamp = true && this.isSetTimestamp();
+ boolean that_present_timestamp = true && that.isSetTimestamp();
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_caching = true && this.isSetCaching();
+ boolean that_present_caching = true && that.isSetCaching();
+ if (this_present_caching || that_present_caching) {
+ if (!(this_present_caching && that_present_caching))
+ return false;
+ if (this.caching != that.caching)
+ 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;
+ }
+
+ boolean this_present_batchSize = true && this.isSetBatchSize();
+ boolean that_present_batchSize = true && that.isSetBatchSize();
+ if (this_present_batchSize || that_present_batchSize) {
+ if (!(this_present_batchSize && that_present_batchSize))
+ return false;
+ if (this.batchSize != that.batchSize)
+ return false;
+ }
+
+ boolean this_present_sortColumns = true && this.isSetSortColumns();
+ boolean that_present_sortColumns = true && that.isSetSortColumns();
+ if (this_present_sortColumns || that_present_sortColumns) {
+ if (!(this_present_sortColumns && that_present_sortColumns))
+ return false;
+ if (this.sortColumns != that.sortColumns)
+ return false;
+ }
+
+ boolean this_present_reversed = true && this.isSetReversed();
+ boolean that_present_reversed = true && that.isSetReversed();
+ if (this_present_reversed || that_present_reversed) {
+ if (!(this_present_reversed && that_present_reversed))
+ return false;
+ if (this.reversed != that.reversed)
+ return false;
+ }
+
+ boolean this_present_cacheBlocks = true && this.isSetCacheBlocks();
+ boolean that_present_cacheBlocks = true && that.isSetCacheBlocks();
+ if (this_present_cacheBlocks || that_present_cacheBlocks) {
+ if (!(this_present_cacheBlocks && that_present_cacheBlocks))
+ return false;
+ if (this.cacheBlocks != that.cacheBlocks)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetStartRow()) ? 131071 : 524287);
+ if (isSetStartRow())
+ hashCode = hashCode * 8191 + startRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStopRow()) ? 131071 : 524287);
+ if (isSetStopRow())
+ hashCode = hashCode * 8191 + stopRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTimestamp()) ? 131071 : 524287);
+ if (isSetTimestamp())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetCaching()) ? 131071 : 524287);
+ if (isSetCaching())
+ hashCode = hashCode * 8191 + caching;
+
+ hashCode = hashCode * 8191 + ((isSetFilterString()) ? 131071 : 524287);
+ if (isSetFilterString())
+ hashCode = hashCode * 8191 + filterString.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetBatchSize()) ? 131071 : 524287);
+ if (isSetBatchSize())
+ hashCode = hashCode * 8191 + batchSize;
+
+ hashCode = hashCode * 8191 + ((isSetSortColumns()) ? 131071 : 524287);
+ if (isSetSortColumns())
+ hashCode = hashCode * 8191 + ((sortColumns) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetReversed()) ? 131071 : 524287);
+ if (isSetReversed())
+ hashCode = hashCode * 8191 + ((reversed) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetCacheBlocks()) ? 131071 : 524287);
+ if (isSetCacheBlocks())
+ hashCode = hashCode * 8191 + ((cacheBlocks) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TScan other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetStartRow(), other.isSetStartRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, other.startRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStopRow(), other.isSetStopRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStopRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, other.stopRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCaching(), other.isSetCaching());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCaching()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.caching, other.caching);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFilterString(), other.isSetFilterString());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFilterString()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterString, other.filterString);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBatchSize(), other.isSetBatchSize());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBatchSize()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.batchSize, other.batchSize);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetSortColumns(), other.isSetSortColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSortColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sortColumns, other.sortColumns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetReversed(), other.isSetReversed());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReversed()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.reversed, other.reversed);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCacheBlocks(), other.isSetCacheBlocks());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCacheBlocks()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheBlocks, other.cacheBlocks);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TScan(");
+ boolean first = true;
+
+ if (isSetStartRow()) {
+ sb.append("startRow:");
+ if (this.startRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
+ }
+ first = false;
+ }
+ if (isSetStopRow()) {
+ if (!first) sb.append(", ");
+ sb.append("stopRow:");
+ if (this.stopRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.stopRow, sb);
+ }
+ first = false;
+ }
+ if (isSetTimestamp()) {
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ }
+ if (isSetColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.columns, sb);
+ }
+ first = false;
+ }
+ if (isSetCaching()) {
+ if (!first) sb.append(", ");
+ sb.append("caching:");
+ sb.append(this.caching);
+ first = false;
+ }
+ if (isSetFilterString()) {
+ if (!first) sb.append(", ");
+ sb.append("filterString:");
+ if (this.filterString == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.filterString, sb);
+ }
+ first = false;
+ }
+ if (isSetBatchSize()) {
+ if (!first) sb.append(", ");
+ sb.append("batchSize:");
+ sb.append(this.batchSize);
+ first = false;
+ }
+ if (isSetSortColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("sortColumns:");
+ sb.append(this.sortColumns);
+ first = false;
+ }
+ if (isSetReversed()) {
+ if (!first) sb.append(", ");
+ sb.append("reversed:");
+ sb.append(this.reversed);
+ first = false;
+ }
+ if (isSetCacheBlocks()) {
+ if (!first) sb.append(", ");
+ sb.append("cacheBlocks:");
+ sb.append(this.cacheBlocks);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TScanStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TScanStandardScheme getScheme() {
+ return new TScanStandardScheme();
+ }
+ }
+
+ private static class TScanStandardScheme extends org.apache.thrift.scheme.StandardScheme<TScan> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TScan struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // START_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // STOP_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list26 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list26.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem27;
+ for (int _i28 = 0; _i28 < _list26.size; ++_i28)
+ {
+ _elem27 = iprot.readBinary();
+ struct.columns.add(_elem27);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // CACHING
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.caching = iprot.readI32();
+ struct.setCachingIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // FILTER_STRING
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.filterString = iprot.readBinary();
+ struct.setFilterStringIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // BATCH_SIZE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.batchSize = iprot.readI32();
+ struct.setBatchSizeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 8: // SORT_COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.sortColumns = iprot.readBool();
+ struct.setSortColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 9: // REVERSED
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.reversed = iprot.readBool();
+ struct.setReversedIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 10: // CACHE_BLOCKS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.cacheBlocks = iprot.readBool();
+ struct.setCacheBlocksIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TScan struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.startRow != null) {
+ if (struct.isSetStartRow()) {
+ oprot.writeFieldBegin(START_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.startRow);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.stopRow != null) {
+ if (struct.isSetStopRow()) {
+ oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.stopRow);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ if (struct.isSetColumns()) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
+ for (java.nio.ByteBuffer _iter29 : struct.columns)
+ {
+ oprot.writeBinary(_iter29);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetCaching()) {
+ oprot.writeFieldBegin(CACHING_FIELD_DESC);
+ oprot.writeI32(struct.caching);
+ oprot.writeFieldEnd();
+ }
+ if (struct.filterString != null) {
+ if (struct.isSetFilterString()) {
+ oprot.writeFieldBegin(FILTER_STRING_FIELD_DESC);
+ oprot.writeBinary(struct.filterString);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetBatchSize()) {
+ oprot.writeFieldBegin(BATCH_SIZE_FIELD_DESC);
+ oprot.writeI32(struct.batchSize);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetSortColumns()) {
+ oprot.writeFieldBegin(SORT_COLUMNS_FIELD_DESC);
+ oprot.writeBool(struct.sortColumns);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetReversed()) {
+ oprot.writeFieldBegin(REVERSED_FIELD_DESC);
+ oprot.writeBool(struct.reversed);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetCacheBlocks()) {
+ oprot.writeFieldBegin(CACHE_BLOCKS_FIELD_DESC);
+ oprot.writeBool(struct.cacheBlocks);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TScanTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TScanTupleScheme getScheme() {
+ return new TScanTupleScheme();
+ }
+ }
+
+ private static class TScanTupleScheme extends org.apache.thrift.scheme.TupleScheme<TScan> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TScan struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetStartRow()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStopRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(2);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(3);
+ }
+ if (struct.isSetCaching()) {
+ optionals.set(4);
+ }
+ if (struct.isSetFilterString()) {
+ optionals.set(5);
+ }
+ if (struct.isSetBatchSize()) {
+ optionals.set(6);
+ }
+ if (struct.isSetSortColumns()) {
+ optionals.set(7);
+ }
+ if (struct.isSetReversed()) {
+ optionals.set(8);
+ }
+ if (struct.isSetCacheBlocks()) {
+ optionals.set(9);
+ }
+ oprot.writeBitSet(optionals, 10);
+ if (struct.isSetStartRow()) {
+ oprot.writeBinary(struct.startRow);
+ }
+ if (struct.isSetStopRow()) {
+ oprot.writeBinary(struct.stopRow);
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (java.nio.ByteBuffer _iter30 : struct.columns)
+ {
+ oprot.writeBinary(_iter30);
+ }
+ }
+ }
+ if (struct.isSetCaching()) {
+ oprot.writeI32(struct.caching);
+ }
+ if (struct.isSetFilterString()) {
+ oprot.writeBinary(struct.filterString);
+ }
+ if (struct.isSetBatchSize()) {
+ oprot.writeI32(struct.batchSize);
+ }
+ if (struct.isSetSortColumns()) {
+ oprot.writeBool(struct.sortColumns);
+ }
+ if (struct.isSetReversed()) {
+ oprot.writeBool(struct.reversed);
+ }
+ if (struct.isSetCacheBlocks()) {
+ oprot.writeBool(struct.cacheBlocks);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TScan struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(10);
+ if (incoming.get(0)) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TList _list31 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.columns = new java.util.ArrayList<java.nio.ByteBuffer>(_list31.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem32;
+ for (int _i33 = 0; _i33 < _list31.size; ++_i33)
+ {
+ _elem32 = iprot.readBinary();
+ struct.columns.add(_elem32);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.caching = iprot.readI32();
+ struct.setCachingIsSet(true);
+ }
+ if (incoming.get(5)) {
+ struct.filterString = iprot.readBinary();
+ struct.setFilterStringIsSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.batchSize = iprot.readI32();
+ struct.setBatchSizeIsSet(true);
+ }
+ if (incoming.get(7)) {
+ struct.sortColumns = iprot.readBool();
+ struct.setSortColumnsIsSet(true);
+ }
+ if (incoming.get(8)) {
+ struct.reversed = iprot.readBool();
+ struct.setReversedIsSet(true);
+ }
+ if (incoming.get(9)) {
+ struct.cacheBlocks = iprot.readBool();
+ struct.setCacheBlocksIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TThriftServerType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TThriftServerType.java
new file mode 100644
index 0000000..17bdd3e
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/generated/TThriftServerType.java
@@ -0,0 +1,46 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift.generated;
+
+
+/**
+ * Specify type of thrift server: thrift and thrift2
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TThriftServerType implements org.apache.thrift.TEnum {
+ ONE(1),
+ TWO(2);
+
+ private final int value;
+
+ private TThriftServerType(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TThriftServerType findByValue(int value) {
+ switch (value) {
+ case 1:
+ return ONE;
+ case 2:
+ return TWO;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/util/ConnectionCache.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/util/ConnectionCache.java
new file mode 100644
index 0000000..e45cd80
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift/util/ConnectionCache.java
@@ -0,0 +1,259 @@
+/*
+ * 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.thrift.util;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.Lock;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.ChoreService;
+import org.apache.hadoop.hbase.ScheduledChore;
+import org.apache.hadoop.hbase.Stoppable;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.Admin;
+import org.apache.hadoop.hbase.client.Connection;
+import org.apache.hadoop.hbase.client.ConnectionFactory;
+import org.apache.hadoop.hbase.client.RegionLocator;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.security.User;
+import org.apache.hadoop.hbase.security.UserProvider;
+import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
+import org.apache.hadoop.hbase.util.KeyLocker;
+import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A utility to store user specific HConnections in memory. There is a chore to clean up connections
+ * idle for too long. This class is used by REST server and Thrift server to support authentication
+ * and impersonation.
+ */
+@InterfaceAudience.Private
+public class ConnectionCache {
+ private static final Logger LOG = LoggerFactory.getLogger(ConnectionCache.class);
+
+ private final Map<String, ConnectionInfo> connections = new ConcurrentHashMap<>();
+ private final KeyLocker<String> locker = new KeyLocker<>();
+ private final String realUserName;
+ private final UserGroupInformation realUser;
+ private final UserProvider userProvider;
+ private final Configuration conf;
+ private final ChoreService choreService;
+
+ private final ThreadLocal<String> effectiveUserNames = new ThreadLocal<String>() {
+ @Override
+ protected String initialValue() {
+ return realUserName;
+ }
+ };
+
+ public ConnectionCache(final Configuration conf, final UserProvider userProvider,
+ final int cleanInterval, final int maxIdleTime) throws IOException {
+ Stoppable stoppable = new Stoppable() {
+ private volatile boolean isStopped = false;
+
+ @Override
+ public void stop(String why) {
+ isStopped = true;
+ }
+
+ @Override
+ public boolean isStopped() {
+ return isStopped;
+ }
+ };
+ this.choreService = new ChoreService("ConnectionCache");
+ ScheduledChore cleaner = new ScheduledChore("ConnectionCleaner", stoppable, cleanInterval) {
+ @Override
+ protected void chore() {
+ for (Map.Entry<String, ConnectionInfo> entry : connections.entrySet()) {
+ ConnectionInfo connInfo = entry.getValue();
+ if (connInfo.timedOut(maxIdleTime)) {
+ if (connInfo.admin != null) {
+ try {
+ connInfo.admin.close();
+ } catch (Throwable t) {
+ LOG.info("Got exception in closing idle admin", t);
+ }
+ }
+ try {
+ connInfo.connection.close();
+ } catch (Throwable t) {
+ LOG.info("Got exception in closing idle connection", t);
+ }
+ }
+ }
+ }
+ };
+ // Start the daemon cleaner chore
+ choreService.scheduleChore(cleaner);
+ this.realUser = userProvider.getCurrent().getUGI();
+ this.realUserName = realUser.getShortUserName();
+ this.userProvider = userProvider;
+ this.conf = conf;
+ }
+
+ /**
+ * Set the current thread local effective user
+ */
+ public void setEffectiveUser(String user) {
+ effectiveUserNames.set(user);
+ }
+
+ /**
+ * Get the current thread local effective user
+ */
+ public String getEffectiveUser() {
+ return effectiveUserNames.get();
+ }
+
+ /**
+ * Called when cache is no longer needed so that it can perform cleanup operations
+ */
+ public void shutdown() {
+ if (choreService != null) choreService.shutdown();
+ }
+
+ /**
+ * Caller doesn't close the admin afterwards. We need to manage it and close it properly.
+ */
+ public Admin getAdmin() throws IOException {
+ ConnectionInfo connInfo = getCurrentConnection();
+ if (connInfo.admin == null) {
+ Lock lock = locker.acquireLock(getEffectiveUser());
+ try {
+ if (connInfo.admin == null) {
+ connInfo.admin = connInfo.connection.getAdmin();
+ }
+ } finally {
+ lock.unlock();
+ }
+ }
+ return connInfo.admin;
+ }
+
+ /**
+ * Caller closes the table afterwards.
+ */
+ public Table getTable(String tableName) throws IOException {
+ ConnectionInfo connInfo = getCurrentConnection();
+ return connInfo.connection.getTable(TableName.valueOf(tableName));
+ }
+
+ /**
+ * Retrieve a regionLocator for the table. The user should close the RegionLocator.
+ */
+ public RegionLocator getRegionLocator(byte[] tableName) throws IOException {
+ return getCurrentConnection().connection.getRegionLocator(TableName.valueOf(tableName));
+ }
+
+ /**
+ * Get the cached connection for the current user. If none or timed out, create a new one.
+ */
+ ConnectionInfo getCurrentConnection() throws IOException {
+ String userName = getEffectiveUser();
+ ConnectionInfo connInfo = connections.get(userName);
+ if (connInfo == null || !connInfo.updateAccessTime()) {
+ Lock lock = locker.acquireLock(userName);
+ try {
+ connInfo = connections.get(userName);
+ if (connInfo == null) {
+ UserGroupInformation ugi = realUser;
+ if (!userName.equals(realUserName)) {
+ ugi = UserGroupInformation.createProxyUser(userName, realUser);
+ }
+ User user = userProvider.create(ugi);
+ Connection conn = ConnectionFactory.createConnection(conf, user);
+ connInfo = new ConnectionInfo(conn, userName);
+ connections.put(userName, connInfo);
+ }
+ } finally {
+ lock.unlock();
+ }
+ }
+ return connInfo;
+ }
+
+ /**
+ * Updates the access time for the current connection. Used to keep Connections alive for
+ * long-lived scanners.
+ * @return whether we successfully updated the last access time
+ */
+ public boolean updateConnectionAccessTime() {
+ String userName = getEffectiveUser();
+ ConnectionInfo connInfo = connections.get(userName);
+ if (connInfo != null) {
+ return connInfo.updateAccessTime();
+ }
+ return false;
+ }
+
+ /**
+ * @return Cluster ID for the HBase cluster or null if there is an err making the connection.
+ */
+ public String getClusterId() {
+ try {
+ ConnectionInfo connInfo = getCurrentConnection();
+ return connInfo.connection.getClusterId();
+ } catch (IOException e) {
+ LOG.error("Error getting connection: ", e);
+ }
+ return null;
+ }
+
+ class ConnectionInfo {
+ final Connection connection;
+ final String userName;
+
+ volatile Admin admin;
+ private long lastAccessTime;
+ private boolean closed;
+
+ ConnectionInfo(Connection conn, String user) {
+ lastAccessTime = EnvironmentEdgeManager.currentTime();
+ connection = conn;
+ closed = false;
+ userName = user;
+ }
+
+ synchronized boolean updateAccessTime() {
+ if (closed) {
+ return false;
+ }
+ if (connection.isAborted() || connection.isClosed()) {
+ LOG.info("Unexpected: cached Connection is aborted/closed, removed from cache");
+ connections.remove(userName);
+ return false;
+ }
+ lastAccessTime = EnvironmentEdgeManager.currentTime();
+ return true;
+ }
+
+ synchronized boolean timedOut(int maxIdleTime) {
+ long timeoutTime = lastAccessTime + maxIdleTime;
+ if (EnvironmentEdgeManager.currentTime() > timeoutTime) {
+ connections.remove(userName);
+ closed = true;
+ return true;
+ }
+ return false;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java
new file mode 100644
index 0000000..a20c7cd
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java
@@ -0,0 +1,918 @@
+/*
+ * 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.thrift2;
+
+import static org.apache.hadoop.hbase.HConstants.DEFAULT_HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD;
+import static org.apache.hadoop.hbase.HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_READONLY_ENABLED;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_READONLY_ENABLED_DEFAULT;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.appendFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.columnFamilyDescriptorFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.compareOpFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.deleteFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.deletesFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.getFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.getsFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.incrementFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.namespaceDescriptorFromHBase;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.namespaceDescriptorFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.namespaceDescriptorsFromHBase;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.putFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.putsFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.resultFromHBase;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.resultsFromHBase;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.rowMutationsFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.scanFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.splitKeyFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableDescriptorFromHBase;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableDescriptorFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableDescriptorsFromHBase;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableNameFromThrift;
+import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableNamesFromHBase;
+import static org.apache.thrift.TBaseHelper.byteBufferToByteArray;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.regex.Pattern;
+import org.apache.commons.lang3.NotImplementedException;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.DoNotRetryIOException;
+import org.apache.hadoop.hbase.HRegionLocation;
+import org.apache.hadoop.hbase.NamespaceDescriptor;
+import org.apache.hadoop.hbase.ServerName;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.client.LogQueryFilter;
+import org.apache.hadoop.hbase.client.OnlineLogRecord;
+import org.apache.hadoop.hbase.client.RegionLocator;
+import org.apache.hadoop.hbase.client.ResultScanner;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.security.UserProvider;
+import org.apache.hadoop.hbase.security.access.AccessControlClient;
+import org.apache.hadoop.hbase.security.access.Permission;
+import org.apache.hadoop.hbase.thrift.HBaseServiceHandler;
+import org.apache.hadoop.hbase.thrift2.generated.TAccessControlEntity;
+import org.apache.hadoop.hbase.thrift2.generated.TAppend;
+import org.apache.hadoop.hbase.thrift2.generated.TColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TCompareOperator;
+import org.apache.hadoop.hbase.thrift2.generated.TDelete;
+import org.apache.hadoop.hbase.thrift2.generated.TGet;
+import org.apache.hadoop.hbase.thrift2.generated.THBaseService;
+import org.apache.hadoop.hbase.thrift2.generated.THRegionLocation;
+import org.apache.hadoop.hbase.thrift2.generated.TIOError;
+import org.apache.hadoop.hbase.thrift2.generated.TIllegalArgument;
+import org.apache.hadoop.hbase.thrift2.generated.TIncrement;
+import org.apache.hadoop.hbase.thrift2.generated.TLogQueryFilter;
+import org.apache.hadoop.hbase.thrift2.generated.TNamespaceDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TOnlineLogRecord;
+import org.apache.hadoop.hbase.thrift2.generated.TPermissionScope;
+import org.apache.hadoop.hbase.thrift2.generated.TPut;
+import org.apache.hadoop.hbase.thrift2.generated.TResult;
+import org.apache.hadoop.hbase.thrift2.generated.TRowMutations;
+import org.apache.hadoop.hbase.thrift2.generated.TScan;
+import org.apache.hadoop.hbase.thrift2.generated.TServerName;
+import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TTableName;
+import org.apache.hadoop.hbase.thrift2.generated.TThriftServerType;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.thrift.TException;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.com.google.common.cache.Cache;
+import org.apache.hbase.thirdparty.com.google.common.cache.CacheBuilder;
+import org.apache.hbase.thirdparty.com.google.common.cache.RemovalListener;
+
+/**
+ * This class is a glue object that connects Thrift RPC calls to the HBase client API primarily
+ * defined in the Table interface.
+ */
+@InterfaceAudience.Private
+@SuppressWarnings("deprecation")
+public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements THBaseService.Iface {
+
+ // TODO: Size of pool configuraple
+ private static final Logger LOG = LoggerFactory.getLogger(ThriftHBaseServiceHandler.class);
+
+ // nextScannerId and scannerMap are used to manage scanner state
+ private final AtomicInteger nextScannerId = new AtomicInteger(0);
+ private final Cache<Integer, ResultScanner> scannerMap;
+
+ private static final IOException ioe =
+ new DoNotRetryIOException("Thrift Server is in Read-only mode.");
+ private boolean isReadOnly;
+
+ private static class TIOErrorWithCause extends TIOError {
+ private Throwable cause;
+
+ public TIOErrorWithCause(Throwable cause) {
+ super();
+ this.cause = cause;
+ }
+
+ @Override
+ public synchronized Throwable getCause() {
+ return cause;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (super.equals(other) && other instanceof TIOErrorWithCause) {
+ Throwable otherCause = ((TIOErrorWithCause) other).getCause();
+ if (this.getCause() != null) {
+ return otherCause != null && this.getCause().equals(otherCause);
+ } else {
+ return otherCause == null;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = super.hashCode();
+ result = 31 * result + (cause != null ? cause.hashCode() : 0);
+ return result;
+ }
+ }
+
+ public ThriftHBaseServiceHandler(final Configuration conf, final UserProvider userProvider)
+ throws IOException {
+ super(conf, userProvider);
+ long cacheTimeout = conf.getLong(HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD,
+ DEFAULT_HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD);
+ isReadOnly = conf.getBoolean(THRIFT_READONLY_ENABLED, THRIFT_READONLY_ENABLED_DEFAULT);
+ scannerMap = CacheBuilder.newBuilder().expireAfterAccess(cacheTimeout, TimeUnit.MILLISECONDS)
+ .removalListener((RemovalListener<Integer,
+ ResultScanner>) removalNotification -> removalNotification.getValue().close())
+ .build();
+ }
+
+ @Override
+ protected Table getTable(ByteBuffer tableName) {
+ try {
+ return connectionCache.getTable(Bytes.toString(byteBufferToByteArray(tableName)));
+ } catch (IOException ie) {
+ throw new RuntimeException(ie);
+ }
+ }
+
+ private RegionLocator getLocator(ByteBuffer tableName) {
+ try {
+ return connectionCache.getRegionLocator(byteBufferToByteArray(tableName));
+ } catch (IOException ie) {
+ throw new RuntimeException(ie);
+ }
+ }
+
+ private void closeTable(Table table) throws TIOError {
+ try {
+ table.close();
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ private TIOError getTIOError(IOException e) {
+ TIOError err = new TIOErrorWithCause(e);
+ err.setCanRetry(!(e instanceof DoNotRetryIOException));
+ err.setMessage(e.getMessage());
+ return err;
+ }
+
+ /**
+ * Assigns a unique ID to the scanner and adds the mapping to an internal HashMap.
+ * @param scanner to add
+ * @return Id for this Scanner
+ */
+ private int addScanner(ResultScanner scanner) {
+ int id = nextScannerId.getAndIncrement();
+ scannerMap.put(id, scanner);
+ return id;
+ }
+
+ /**
+ * Returns the Scanner associated with the specified Id.
+ * @param id of the Scanner to get
+ * @return a Scanner, or null if the Id is invalid
+ */
+ private ResultScanner getScanner(int id) {
+ return scannerMap.getIfPresent(id);
+ }
+
+ /**
+ * Removes the scanner associated with the specified ID from the internal HashMap.
+ * @param id of the Scanner to remove
+ */
+ protected void removeScanner(int id) {
+ scannerMap.invalidate(id);
+ }
+
+ @Override
+ public boolean exists(ByteBuffer table, TGet get) throws TIOError, TException {
+ Table htable = getTable(table);
+ try {
+ return htable.exists(getFromThrift(get));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public List<Boolean> existsAll(ByteBuffer table, List<TGet> gets) throws TIOError, TException {
+ Table htable = getTable(table);
+ try {
+ boolean[] exists = htable.exists(getsFromThrift(gets));
+ List<Boolean> result = new ArrayList<>(exists.length);
+ for (boolean exist : exists) {
+ result.add(exist);
+ }
+ return result;
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public TResult get(ByteBuffer table, TGet get) throws TIOError, TException {
+ Table htable = getTable(table);
+ try {
+ return resultFromHBase(htable.get(getFromThrift(get)));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, TException {
+ Table htable = getTable(table);
+ try {
+ return resultsFromHBase(htable.get(getsFromThrift(gets)));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public void put(ByteBuffer table, TPut put) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ htable.put(putFromThrift(put));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family,
+ ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ Table.CheckAndMutateBuilder builder =
+ htable.checkAndMutate(byteBufferToByteArray(row), byteBufferToByteArray(family))
+ .qualifier(byteBufferToByteArray(qualifier));
+ if (value == null) {
+ return builder.ifNotExists().thenPut(putFromThrift(put));
+ } else {
+ return builder.ifEquals(byteBufferToByteArray(value)).thenPut(putFromThrift(put));
+ }
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ htable.put(putsFromThrift(puts));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ htable.delete(deleteFromThrift(deleteSingle));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes)
+ throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ htable.delete(deletesFromThrift(deletes));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ return Collections.emptyList();
+ }
+
+ @Override
+ public boolean checkAndMutate(ByteBuffer table, ByteBuffer row, ByteBuffer family,
+ ByteBuffer qualifier, TCompareOperator compareOp, ByteBuffer value, TRowMutations rowMutations)
+ throws TIOError, TException {
+ checkReadOnlyMode();
+ try (final Table htable = getTable(table)) {
+ return htable.checkAndMutate(byteBufferToByteArray(row), byteBufferToByteArray(family))
+ .qualifier(byteBufferToByteArray(qualifier))
+ .ifMatches(compareOpFromThrift(compareOp), byteBufferToByteArray(value))
+ .thenMutate(rowMutationsFromThrift(rowMutations));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family,
+ ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ Table.CheckAndMutateBuilder mutateBuilder =
+ htable.checkAndMutate(byteBufferToByteArray(row), byteBufferToByteArray(family))
+ .qualifier(byteBufferToByteArray(qualifier));
+ if (value == null) {
+ return mutateBuilder.ifNotExists().thenDelete(deleteFromThrift(deleteSingle));
+ } else {
+ return mutateBuilder.ifEquals(byteBufferToByteArray(value))
+ .thenDelete(deleteFromThrift(deleteSingle));
+ }
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ return resultFromHBase(htable.increment(incrementFromThrift(increment)));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public TResult append(ByteBuffer table, TAppend append) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ return resultFromHBase(htable.append(appendFromThrift(append)));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public int openScanner(ByteBuffer table, TScan scan) throws TIOError, TException {
+ Table htable = getTable(table);
+ ResultScanner resultScanner = null;
+ try {
+ resultScanner = htable.getScanner(scanFromThrift(scan));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ return addScanner(resultScanner);
+ }
+
+ @Override
+ public List<TResult> getScannerRows(int scannerId, int numRows)
+ throws TIOError, TIllegalArgument, TException {
+ ResultScanner scanner = getScanner(scannerId);
+ if (scanner == null) {
+ TIllegalArgument ex = new TIllegalArgument();
+ ex.setMessage("Invalid scanner Id");
+ throw ex;
+ }
+ try {
+ connectionCache.updateConnectionAccessTime();
+ return resultsFromHBase(scanner.next(numRows));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<TResult> getScannerResults(ByteBuffer table, TScan scan, int numRows)
+ throws TIOError, TException {
+ Table htable = getTable(table);
+ List<TResult> results = null;
+ ResultScanner scanner = null;
+ try {
+ scanner = htable.getScanner(scanFromThrift(scan));
+ results = resultsFromHBase(scanner.next(numRows));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ if (scanner != null) {
+ scanner.close();
+ }
+ closeTable(htable);
+ }
+ return results;
+ }
+
+ @Override
+ public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, TException {
+ LOG.debug("scannerClose: id=" + scannerId);
+ ResultScanner scanner = getScanner(scannerId);
+ if (scanner == null) {
+ LOG.warn("scanner ID: " + scannerId + "is invalid");
+ // While the scanner could be already expired,
+ // we should not throw exception here. Just log and return.
+ return;
+ }
+ scanner.close();
+ removeScanner(scannerId);
+ }
+
+ @Override
+ public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, TException {
+ checkReadOnlyMode();
+ Table htable = getTable(table);
+ try {
+ htable.mutateRow(rowMutationsFromThrift(rowMutations));
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ closeTable(htable);
+ }
+ }
+
+ @Override
+ public List<THRegionLocation> getAllRegionLocations(ByteBuffer table)
+ throws TIOError, TException {
+ RegionLocator locator = null;
+ try {
+ locator = getLocator(table);
+ return ThriftUtilities.regionLocationsFromHBase(locator.getAllRegionLocations());
+
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ if (locator != null) {
+ try {
+ locator.close();
+ } catch (IOException e) {
+ LOG.warn("Couldn't close the locator.", e);
+ }
+ }
+ }
+ }
+
+ @Override
+ public THRegionLocation getRegionLocation(ByteBuffer table, ByteBuffer row, boolean reload)
+ throws TIOError, TException {
+
+ RegionLocator locator = null;
+ try {
+ locator = getLocator(table);
+ byte[] rowBytes = byteBufferToByteArray(row);
+ HRegionLocation hrl = locator.getRegionLocation(rowBytes, reload);
+ return ThriftUtilities.regionLocationFromHBase(hrl);
+
+ } catch (IOException e) {
+ throw getTIOError(e);
+ } finally {
+ if (locator != null) {
+ try {
+ locator.close();
+ } catch (IOException e) {
+ LOG.warn("Couldn't close the locator.", e);
+ }
+ }
+ }
+ }
+
+ private void checkReadOnlyMode() throws TIOError {
+ if (isReadOnly()) {
+ throw getTIOError(ioe);
+ }
+ }
+
+ private boolean isReadOnly() {
+ return isReadOnly;
+ }
+
+ @Override
+ public TTableDescriptor getTableDescriptor(TTableName table) throws TIOError, TException {
+ try {
+ TableName tableName = ThriftUtilities.tableNameFromThrift(table);
+ TableDescriptor tableDescriptor = connectionCache.getAdmin().getDescriptor(tableName);
+ return tableDescriptorFromHBase(tableDescriptor);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<TTableDescriptor> getTableDescriptors(List<TTableName> tables)
+ throws TIOError, TException {
+ try {
+ List<TableName> tableNames = ThriftUtilities.tableNamesFromThrift(tables);
+ List<TableDescriptor> tableDescriptors =
+ connectionCache.getAdmin().listTableDescriptors(tableNames);
+ return tableDescriptorsFromHBase(tableDescriptors);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public boolean tableExists(TTableName tTableName) throws TIOError, TException {
+ try {
+ TableName tableName = tableNameFromThrift(tTableName);
+ return connectionCache.getAdmin().tableExists(tableName);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<TTableDescriptor> getTableDescriptorsByPattern(String regex, boolean includeSysTables)
+ throws TIOError, TException {
+ try {
+ Pattern pattern = (regex == null ? null : Pattern.compile(regex));
+ List<TableDescriptor> tableDescriptors =
+ connectionCache.getAdmin().listTableDescriptors(pattern, includeSysTables);
+ return tableDescriptorsFromHBase(tableDescriptors);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<TTableDescriptor> getTableDescriptorsByNamespace(String name)
+ throws TIOError, TException {
+ try {
+ List<TableDescriptor> descriptors =
+ connectionCache.getAdmin().listTableDescriptorsByNamespace(Bytes.toBytes(name));
+ return tableDescriptorsFromHBase(descriptors);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<TTableName> getTableNamesByPattern(String regex, boolean includeSysTables)
+ throws TIOError, TException {
+ try {
+ Pattern pattern = (regex == null ? null : Pattern.compile(regex));
+ TableName[] tableNames = connectionCache.getAdmin().listTableNames(pattern, includeSysTables);
+ return tableNamesFromHBase(tableNames);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<TTableName> getTableNamesByNamespace(String name) throws TIOError, TException {
+ try {
+ TableName[] tableNames = connectionCache.getAdmin().listTableNamesByNamespace(name);
+ return tableNamesFromHBase(tableNames);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void createTable(TTableDescriptor desc, List<ByteBuffer> splitKeys)
+ throws TIOError, TException {
+ try {
+ TableDescriptor descriptor = tableDescriptorFromThrift(desc);
+ byte[][] split = splitKeyFromThrift(splitKeys);
+ if (split != null) {
+ connectionCache.getAdmin().createTable(descriptor, split);
+ } else {
+ connectionCache.getAdmin().createTable(descriptor);
+ }
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void deleteTable(TTableName tableName) throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ connectionCache.getAdmin().deleteTable(table);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void truncateTable(TTableName tableName, boolean preserveSplits)
+ throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ connectionCache.getAdmin().truncateTable(table, preserveSplits);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void enableTable(TTableName tableName) throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ connectionCache.getAdmin().enableTable(table);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void disableTable(TTableName tableName) throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ connectionCache.getAdmin().disableTable(table);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public boolean isTableEnabled(TTableName tableName) throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ return connectionCache.getAdmin().isTableEnabled(table);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public boolean isTableDisabled(TTableName tableName) throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ return connectionCache.getAdmin().isTableDisabled(table);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public boolean isTableAvailable(TTableName tableName) throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ return connectionCache.getAdmin().isTableAvailable(table);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public boolean isTableAvailableWithSplit(TTableName tableName, List<ByteBuffer> splitKeys)
+ throws TIOError, TException {
+ throw new NotImplementedException("isTableAvailableWithSplit not supported");
+ }
+
+ @Override
+ public void addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column)
+ throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ ColumnFamilyDescriptor columnFamilyDescriptor = columnFamilyDescriptorFromThrift(column);
+ connectionCache.getAdmin().addColumnFamily(table, columnFamilyDescriptor);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void deleteColumnFamily(TTableName tableName, ByteBuffer column)
+ throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ connectionCache.getAdmin().deleteColumnFamily(table, column.array());
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column)
+ throws TIOError, TException {
+ try {
+ TableName table = tableNameFromThrift(tableName);
+ ColumnFamilyDescriptor columnFamilyDescriptor = columnFamilyDescriptorFromThrift(column);
+ connectionCache.getAdmin().modifyColumnFamily(table, columnFamilyDescriptor);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void modifyTable(TTableDescriptor desc) throws TIOError, TException {
+ try {
+ TableDescriptor descriptor = tableDescriptorFromThrift(desc);
+ connectionCache.getAdmin().modifyTable(descriptor);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void createNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, TException {
+ try {
+ NamespaceDescriptor descriptor = namespaceDescriptorFromThrift(namespaceDesc);
+ connectionCache.getAdmin().createNamespace(descriptor);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void modifyNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, TException {
+ try {
+ NamespaceDescriptor descriptor = namespaceDescriptorFromThrift(namespaceDesc);
+ connectionCache.getAdmin().modifyNamespace(descriptor);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public void deleteNamespace(String name) throws TIOError, TException {
+ try {
+ connectionCache.getAdmin().deleteNamespace(name);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public TNamespaceDescriptor getNamespaceDescriptor(String name) throws TIOError, TException {
+ try {
+ NamespaceDescriptor descriptor = connectionCache.getAdmin().getNamespaceDescriptor(name);
+ return namespaceDescriptorFromHBase(descriptor);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<String> listNamespaces() throws TIOError, TException {
+ try {
+ String[] namespaces = connectionCache.getAdmin().listNamespaces();
+ List<String> result = new ArrayList<>(namespaces.length);
+ for (String ns : namespaces) {
+ result.add(ns);
+ }
+ return result;
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public TThriftServerType getThriftServerType() {
+ return TThriftServerType.TWO;
+ }
+
+ @Override
+ public String getClusterId() throws TException {
+ return connectionCache.getClusterId();
+ }
+
+ @Override
+ public List<TOnlineLogRecord> getSlowLogResponses(Set<TServerName> tServerNames,
+ TLogQueryFilter tLogQueryFilter) throws TIOError, TException {
+ try {
+ Set<ServerName> serverNames = ThriftUtilities.getServerNamesFromThrift(tServerNames);
+ LogQueryFilter logQueryFilter = ThriftUtilities.getSlowLogQueryFromThrift(tLogQueryFilter);
+ List<OnlineLogRecord> onlineLogRecords =
+ connectionCache.getAdmin().getSlowLogResponses(serverNames, logQueryFilter);
+ return ThriftUtilities.getSlowLogRecordsFromHBase(onlineLogRecords);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public List<Boolean> clearSlowLogResponses(Set<TServerName> tServerNames)
+ throws TIOError, TException {
+ Set<ServerName> serverNames = ThriftUtilities.getServerNamesFromThrift(tServerNames);
+ try {
+ return connectionCache.getAdmin().clearSlowLogResponses(serverNames);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+
+ @Override
+ public boolean grant(TAccessControlEntity info) throws TIOError, TException {
+ Permission.Action[] actions = ThriftUtilities.permissionActionsFromString(info.actions);
+ try {
+ if (info.scope == TPermissionScope.NAMESPACE) {
+ AccessControlClient.grant(connectionCache.getAdmin().getConnection(), info.getNsName(),
+ info.getUsername(), actions);
+ } else if (info.scope == TPermissionScope.TABLE) {
+ TableName tableName = TableName.valueOf(info.getTableName());
+ AccessControlClient.grant(connectionCache.getAdmin().getConnection(), tableName,
+ info.getUsername(), null, null, actions);
+ }
+ } catch (Throwable t) {
+ if (t instanceof IOException) {
+ throw getTIOError((IOException) t);
+ } else {
+ throw getTIOError(new DoNotRetryIOException(t.getMessage()));
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public boolean revoke(TAccessControlEntity info) throws TIOError, TException {
+ Permission.Action[] actions = ThriftUtilities.permissionActionsFromString(info.actions);
+ try {
+ if (info.scope == TPermissionScope.NAMESPACE) {
+ AccessControlClient.revoke(connectionCache.getAdmin().getConnection(), info.getNsName(),
+ info.getUsername(), actions);
+ } else if (info.scope == TPermissionScope.TABLE) {
+ TableName tableName = TableName.valueOf(info.getTableName());
+ AccessControlClient.revoke(connectionCache.getAdmin().getConnection(), tableName,
+ info.getUsername(), null, null, actions);
+ }
+ } catch (Throwable t) {
+ if (t instanceof IOException) {
+ throw getTIOError((IOException) t);
+ } else {
+ throw getTIOError(new DoNotRetryIOException(t.getMessage()));
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public List<TNamespaceDescriptor> listNamespaceDescriptors() throws TIOError, TException {
+ try {
+ NamespaceDescriptor[] descriptors = connectionCache.getAdmin().listNamespaceDescriptors();
+ return namespaceDescriptorsFromHBase(descriptors);
+ } catch (IOException e) {
+ throw getTIOError(e);
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftServer.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftServer.java
new file mode 100644
index 0000000..3d403c5
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftServer.java
@@ -0,0 +1,114 @@
+/*
+ * 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.thrift2;
+
+import static org.apache.hadoop.hbase.thrift.Constants.READONLY_OPTION;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_READONLY_ENABLED;
+import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_READONLY_ENABLED_DEFAULT;
+
+import java.io.IOException;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.HBaseConfiguration;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.security.UserProvider;
+import org.apache.hadoop.hbase.thrift.HBaseServiceHandler;
+import org.apache.hadoop.hbase.thrift.HbaseHandlerMetricsProxy;
+import org.apache.hadoop.hbase.thrift.ThriftMetrics;
+import org.apache.hadoop.hbase.thrift2.generated.THBaseService;
+import org.apache.hadoop.util.Shell;
+import org.apache.hadoop.util.ToolRunner;
+import org.apache.thrift.TProcessor;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.org.apache.commons.cli.CommandLine;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.HelpFormatter;
+import org.apache.hbase.thirdparty.org.apache.commons.cli.Options;
+
+/**
+ * ThriftServer - this class starts up a Thrift server which implements the HBase API specified in
+ * the HbaseClient.thrift IDL file.
+ */
+@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "NM_SAME_SIMPLE_NAME_AS_SUPERCLASS",
+ justification = "Change the name will be an incompatible change, will do it later")
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.TOOLS)
+@SuppressWarnings({ "rawtypes", "unchecked" })
+public class ThriftServer extends org.apache.hadoop.hbase.thrift.ThriftServer {
+ private static final Logger log = LoggerFactory.getLogger(ThriftServer.class);
+
+ public ThriftServer(Configuration conf) {
+ super(conf);
+ }
+
+ @Override
+ protected void printUsageAndExit(Options options, int exitCode) throws Shell.ExitCodeException {
+ HelpFormatter formatter = new HelpFormatter();
+ formatter.printHelp("Thrift", null, options,
+ "To start the Thrift server run 'hbase-daemon.sh start thrift2' or " + "'hbase thrift2'\n"
+ + "To shutdown the thrift server run 'hbase-daemon.sh stop thrift2' or"
+ + " send a kill signal to the thrift server pid",
+ true);
+ throw new Shell.ExitCodeException(exitCode, "");
+ }
+
+ @Override
+ protected HBaseServiceHandler createHandler(Configuration conf, UserProvider userProvider)
+ throws IOException {
+ return new ThriftHBaseServiceHandler(conf, userProvider);
+ }
+
+ @Override
+ protected ThriftMetrics createThriftMetrics(Configuration conf) {
+ return new ThriftMetrics(conf, ThriftMetrics.ThriftServerType.TWO);
+ }
+
+ @Override
+ protected TProcessor createProcessor() {
+ return new THBaseService.Processor<>(HbaseHandlerMetricsProxy
+ .newInstance((THBaseService.Iface) hbaseServiceHandler, metrics, conf));
+ }
+
+ @Override
+ protected void addOptions(Options options) {
+ super.addOptions(options);
+ options.addOption("ro", READONLY_OPTION, false,
+ "Respond only to read method requests [default: false]");
+ }
+
+ @Override
+ protected void parseCommandLine(CommandLine cmd, Options options) throws Shell.ExitCodeException {
+ super.parseCommandLine(cmd, options);
+ boolean readOnly = THRIFT_READONLY_ENABLED_DEFAULT;
+ if (cmd.hasOption(READONLY_OPTION)) {
+ readOnly = true;
+ }
+ conf.setBoolean(THRIFT_READONLY_ENABLED, readOnly);
+ }
+
+ /**
+ * Start up the Thrift2 server.
+ */
+ public static void main(String[] args) throws Exception {
+ final Configuration conf = HBaseConfiguration.create();
+ // for now, only time we return is on an argument error.
+ final int status = ToolRunner.run(conf, new ThriftServer(conf), args);
+ System.exit(status);
+ }
+
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java
new file mode 100644
index 0000000..d2c6ee8
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java
@@ -0,0 +1,1703 @@
+/*
+ * 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.thrift2;
+
+import static org.apache.hadoop.hbase.util.Bytes.getBytes;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.NavigableSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.apache.hadoop.hbase.Cell;
+import org.apache.hadoop.hbase.CellBuilderFactory;
+import org.apache.hadoop.hbase.CellBuilderType;
+import org.apache.hadoop.hbase.CellUtil;
+import org.apache.hadoop.hbase.CompareOperator;
+import org.apache.hadoop.hbase.ExtendedCellBuilder;
+import org.apache.hadoop.hbase.ExtendedCellBuilderFactory;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.HRegionLocation;
+import org.apache.hadoop.hbase.KeepDeletedCells;
+import org.apache.hadoop.hbase.NamespaceDescriptor;
+import org.apache.hadoop.hbase.PrivateCellUtil;
+import org.apache.hadoop.hbase.ServerName;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.Append;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder;
+import org.apache.hadoop.hbase.client.Consistency;
+import org.apache.hadoop.hbase.client.Delete;
+import org.apache.hadoop.hbase.client.Durability;
+import org.apache.hadoop.hbase.client.Get;
+import org.apache.hadoop.hbase.client.Increment;
+import org.apache.hadoop.hbase.client.LogQueryFilter;
+import org.apache.hadoop.hbase.client.Mutation;
+import org.apache.hadoop.hbase.client.OnlineLogRecord;
+import org.apache.hadoop.hbase.client.OperationWithAttributes;
+import org.apache.hadoop.hbase.client.Put;
+import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.client.RowMutations;
+import org.apache.hadoop.hbase.client.Scan;
+import org.apache.hadoop.hbase.client.Scan.ReadType;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
+import org.apache.hadoop.hbase.exceptions.DeserializationException;
+import org.apache.hadoop.hbase.filter.Filter;
+import org.apache.hadoop.hbase.filter.ParseFilter;
+import org.apache.hadoop.hbase.io.TimeRange;
+import org.apache.hadoop.hbase.io.compress.Compression;
+import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding;
+import org.apache.hadoop.hbase.regionserver.BloomType;
+import org.apache.hadoop.hbase.security.access.Permission;
+import org.apache.hadoop.hbase.security.visibility.Authorizations;
+import org.apache.hadoop.hbase.security.visibility.CellVisibility;
+import org.apache.hadoop.hbase.thrift2.generated.TAppend;
+import org.apache.hadoop.hbase.thrift2.generated.TAuthorization;
+import org.apache.hadoop.hbase.thrift2.generated.TBloomFilterType;
+import org.apache.hadoop.hbase.thrift2.generated.TCellVisibility;
+import org.apache.hadoop.hbase.thrift2.generated.TColumn;
+import org.apache.hadoop.hbase.thrift2.generated.TColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TColumnIncrement;
+import org.apache.hadoop.hbase.thrift2.generated.TColumnValue;
+import org.apache.hadoop.hbase.thrift2.generated.TCompareOperator;
+import org.apache.hadoop.hbase.thrift2.generated.TCompressionAlgorithm;
+import org.apache.hadoop.hbase.thrift2.generated.TConsistency;
+import org.apache.hadoop.hbase.thrift2.generated.TDataBlockEncoding;
+import org.apache.hadoop.hbase.thrift2.generated.TDelete;
+import org.apache.hadoop.hbase.thrift2.generated.TDeleteType;
+import org.apache.hadoop.hbase.thrift2.generated.TDurability;
+import org.apache.hadoop.hbase.thrift2.generated.TFilterByOperator;
+import org.apache.hadoop.hbase.thrift2.generated.TGet;
+import org.apache.hadoop.hbase.thrift2.generated.THRegionInfo;
+import org.apache.hadoop.hbase.thrift2.generated.THRegionLocation;
+import org.apache.hadoop.hbase.thrift2.generated.TIncrement;
+import org.apache.hadoop.hbase.thrift2.generated.TKeepDeletedCells;
+import org.apache.hadoop.hbase.thrift2.generated.TLogQueryFilter;
+import org.apache.hadoop.hbase.thrift2.generated.TLogType;
+import org.apache.hadoop.hbase.thrift2.generated.TMutation;
+import org.apache.hadoop.hbase.thrift2.generated.TNamespaceDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TOnlineLogRecord;
+import org.apache.hadoop.hbase.thrift2.generated.TPut;
+import org.apache.hadoop.hbase.thrift2.generated.TReadType;
+import org.apache.hadoop.hbase.thrift2.generated.TResult;
+import org.apache.hadoop.hbase.thrift2.generated.TRowMutations;
+import org.apache.hadoop.hbase.thrift2.generated.TScan;
+import org.apache.hadoop.hbase.thrift2.generated.TServerName;
+import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TTableName;
+import org.apache.hadoop.hbase.thrift2.generated.TTimeRange;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.yetus.audience.InterfaceAudience;
+
+import org.apache.hbase.thirdparty.org.apache.commons.collections4.CollectionUtils;
+import org.apache.hbase.thirdparty.org.apache.commons.collections4.MapUtils;
+
+import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.FilterProtos;
+
+@InterfaceAudience.Private
+public final class ThriftUtilities {
+
+ private final static Cell[] EMPTY_CELL_ARRAY = new Cell[] {};
+ private final static Result EMPTY_RESULT = Result.create(EMPTY_CELL_ARRAY);
+ private final static Result EMPTY_RESULT_STALE = Result.create(EMPTY_CELL_ARRAY, null, true);
+
+ private ThriftUtilities() {
+ throw new UnsupportedOperationException("Can't initialize class");
+ }
+
+ /**
+ * Creates a {@link Get} (HBase) from a {@link TGet} (Thrift). This ignores any timestamps set on
+ * {@link TColumn} objects.
+ * @param in the <code>TGet</code> to convert
+ * @return <code>Get</code> object
+ * @throws IOException if an invalid time range or max version parameter is given
+ */
+ public static Get getFromThrift(TGet in) throws IOException {
+ Get out = new Get(in.getRow());
+
+ // Timestamp overwrites time range if both are set
+ if (in.isSetTimestamp()) {
+ out.setTimestamp(in.getTimestamp());
+ } else if (in.isSetTimeRange()) {
+ out.setTimeRange(in.getTimeRange().getMinStamp(), in.getTimeRange().getMaxStamp());
+ }
+
+ if (in.isSetMaxVersions()) {
+ out.readVersions(in.getMaxVersions());
+ }
+
+ if (in.isSetFilterString()) {
+ ParseFilter parseFilter = new ParseFilter();
+ out.setFilter(parseFilter.parseFilterString(in.getFilterString()));
+ }
+
+ if (in.isSetAttributes()) {
+ addAttributes(out, in.getAttributes());
+ }
+
+ if (in.isSetAuthorizations()) {
+ out.setAuthorizations(new Authorizations(in.getAuthorizations().getLabels()));
+ }
+
+ if (in.isSetConsistency()) {
+ out.setConsistency(consistencyFromThrift(in.getConsistency()));
+ }
+
+ if (in.isSetTargetReplicaId()) {
+ out.setReplicaId(in.getTargetReplicaId());
+ }
+
+ if (in.isSetCacheBlocks()) {
+ out.setCacheBlocks(in.isCacheBlocks());
+ }
+ if (in.isSetStoreLimit()) {
+ out.setMaxResultsPerColumnFamily(in.getStoreLimit());
+ }
+ if (in.isSetStoreOffset()) {
+ out.setRowOffsetPerColumnFamily(in.getStoreOffset());
+ }
+ if (in.isSetExistence_only()) {
+ out.setCheckExistenceOnly(in.isExistence_only());
+ }
+
+ if (in.isSetColumns()) {
+ for (TColumn column : in.getColumns()) {
+ if (column.isSetQualifier()) {
+ out.addColumn(column.getFamily(), column.getQualifier());
+ } else {
+ out.addFamily(column.getFamily());
+ }
+ }
+ }
+
+ if (in.isSetFilterBytes()) {
+ out.setFilter(filterFromThrift(in.getFilterBytes()));
+ }
+ return out;
+ }
+
+ /**
+ * Converts multiple {@link TGet}s (Thrift) into a list of {@link Get}s (HBase).
+ * @param in list of <code>TGet</code>s to convert
+ * @return list of <code>Get</code> objects
+ * @throws IOException if an invalid time range or max version parameter is given
+ * @see #getFromThrift(TGet)
+ */
+ public static List<Get> getsFromThrift(List<TGet> in) throws IOException {
+ List<Get> out = new ArrayList<>(in.size());
+ for (TGet get : in) {
+ out.add(getFromThrift(get));
+ }
+ return out;
+ }
+
+ /**
+ * Creates a {@link TResult} (Thrift) from a {@link Result} (HBase).
+ * @param in the <code>Result</code> to convert
+ * @return converted result, returns an empty result if the input is <code>null</code>
+ */
+ public static TResult resultFromHBase(Result in) {
+ Cell[] raw = in.rawCells();
+ TResult out = new TResult();
+ byte[] row = in.getRow();
+ if (row != null) {
+ out.setRow(in.getRow());
+ }
+ List<TColumnValue> columnValues = new ArrayList<>(raw.length);
+ for (Cell kv : raw) {
+ TColumnValue col = new TColumnValue();
+ col.setFamily(CellUtil.cloneFamily(kv));
+ col.setQualifier(CellUtil.cloneQualifier(kv));
+ col.setTimestamp(kv.getTimestamp());
+ col.setValue(CellUtil.cloneValue(kv));
+ col.setType(kv.getType().getCode());
+ if (kv.getTagsLength() > 0) {
+ col.setTags(PrivateCellUtil.cloneTags(kv));
+ }
+ columnValues.add(col);
+ }
+ out.setColumnValues(columnValues);
+
+ out.setStale(in.isStale());
+
+ out.setPartial(in.mayHaveMoreCellsInRow());
+ return out;
+ }
+
+ /**
+ * Converts multiple {@link Result}s (HBase) into a list of {@link TResult}s (Thrift).
+ * @param in array of <code>Result</code>s to convert
+ * @return list of converted <code>TResult</code>s
+ * @see #resultFromHBase(Result)
+ */
+ public static List<TResult> resultsFromHBase(Result[] in) {
+ List<TResult> out = new ArrayList<>(in.length);
+ for (Result result : in) {
+ out.add(resultFromHBase(result));
+ }
+ return out;
+ }
+
+ /**
+ * Creates a {@link Put} (HBase) from a {@link TPut} (Thrift)
+ * @param in the <code>TPut</code> to convert
+ * @return converted <code>Put</code>
+ */
+ public static Put putFromThrift(TPut in) {
+ Put out;
+
+ if (in.isSetTimestamp()) {
+ out = new Put(in.getRow(), in.getTimestamp());
+ } else {
+ out = new Put(in.getRow());
+ }
+
+ if (in.isSetDurability()) {
+ out.setDurability(durabilityFromThrift(in.getDurability()));
+ }
+
+ for (TColumnValue columnValue : in.getColumnValues()) {
+ try {
+ if (columnValue.isSetTimestamp()) {
+ out.add(CellBuilderFactory.create(CellBuilderType.DEEP_COPY).setRow(out.getRow())
+ .setFamily(columnValue.getFamily()).setQualifier(columnValue.getQualifier())
+ .setTimestamp(columnValue.getTimestamp()).setType(Cell.Type.Put)
+ .setValue(columnValue.getValue()).build());
+ } else {
+ out.add(CellBuilderFactory.create(CellBuilderType.DEEP_COPY).setRow(out.getRow())
+ .setFamily(columnValue.getFamily()).setQualifier(columnValue.getQualifier())
+ .setTimestamp(out.getTimestamp()).setType(Cell.Type.Put)
+ .setValue(columnValue.getValue()).build());
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException((e));
+ }
+ }
+
+ if (in.isSetAttributes()) {
+ addAttributes(out, in.getAttributes());
+ }
+
+ if (in.getCellVisibility() != null) {
+ out.setCellVisibility(new CellVisibility(in.getCellVisibility().getExpression()));
+ }
+
+ return out;
+ }
+
+ /**
+ * Converts multiple {@link TPut}s (Thrift) into a list of {@link Put}s (HBase).
+ * @param in list of <code>TPut</code>s to convert
+ * @return list of converted <code>Put</code>s
+ * @see #putFromThrift(TPut)
+ */
+ public static List<Put> putsFromThrift(List<TPut> in) {
+ List<Put> out = new ArrayList<>(in.size());
+ for (TPut put : in) {
+ out.add(putFromThrift(put));
+ }
+ return out;
+ }
+
+ /**
+ * Creates a {@link Delete} (HBase) from a {@link TDelete} (Thrift).
+ * @param in the <code>TDelete</code> to convert
+ * @return converted <code>Delete</code>
+ */
+ public static Delete deleteFromThrift(TDelete in) {
+ Delete out;
+
+ if (in.isSetColumns()) {
+ out = new Delete(in.getRow());
+ for (TColumn column : in.getColumns()) {
+ if (in.isSetDeleteType()) {
+ switch (in.getDeleteType()) {
+ case DELETE_COLUMN:
+ if (column.isSetTimestamp()) {
+ out.addColumn(column.getFamily(), column.getQualifier(), column.getTimestamp());
+ } else {
+ out.addColumn(column.getFamily(), column.getQualifier());
+ }
+ break;
+ case DELETE_COLUMNS:
+ if (column.isSetTimestamp()) {
+ out.addColumns(column.getFamily(), column.getQualifier(), column.getTimestamp());
+ } else {
+ out.addColumns(column.getFamily(), column.getQualifier());
+ }
+ break;
+ case DELETE_FAMILY:
+ if (column.isSetTimestamp()) {
+ out.addFamily(column.getFamily(), column.getTimestamp());
+ } else {
+ out.addFamily(column.getFamily());
+ }
+ break;
+ case DELETE_FAMILY_VERSION:
+ if (column.isSetTimestamp()) {
+ out.addFamilyVersion(column.getFamily(), column.getTimestamp());
+ } else {
+ throw new IllegalArgumentException(
+ "Timestamp is required for TDelete with DeleteFamilyVersion type");
+ }
+ break;
+ default:
+ throw new IllegalArgumentException("DeleteType is required for TDelete");
+ }
+ } else {
+ throw new IllegalArgumentException("DeleteType is required for TDelete");
+ }
+ }
+ } else {
+ if (in.isSetTimestamp()) {
+ out = new Delete(in.getRow(), in.getTimestamp());
+ } else {
+ out = new Delete(in.getRow());
+ }
+ }
+
+ if (in.isSetAttributes()) {
+ addAttributes(out, in.getAttributes());
+ }
+
+ if (in.isSetDurability()) {
+ out.setDurability(durabilityFromThrift(in.getDurability()));
+ }
+
+ return out;
+ }
+
+ /**
+ * Converts multiple {@link TDelete}s (Thrift) into a list of {@link Delete}s (HBase).
+ * @param in list of <code>TDelete</code>s to convert
+ * @return list of converted <code>Delete</code>s
+ * @see #deleteFromThrift(TDelete)
+ */
+
+ public static List<Delete> deletesFromThrift(List<TDelete> in) {
+ List<Delete> out = new ArrayList<>(in.size());
+ for (TDelete delete : in) {
+ out.add(deleteFromThrift(delete));
+ }
+ return out;
+ }
+
+ public static TDeleteType deleteTypeFromHBase(Cell.Type type) {
+ switch (type) {
+ case Delete:
+ return TDeleteType.DELETE_COLUMN;
+ case DeleteColumn:
+ return TDeleteType.DELETE_COLUMNS;
+ case DeleteFamily:
+ return TDeleteType.DELETE_FAMILY;
+ case DeleteFamilyVersion:
+ return TDeleteType.DELETE_FAMILY_VERSION;
+ default:
+ throw new IllegalArgumentException("Unknow delete type " + type);
+ }
+ }
+
+ public static TDelete deleteFromHBase(Delete in) {
+ TDelete out = new TDelete(ByteBuffer.wrap(in.getRow()));
+
+ List<TColumn> columns = new ArrayList<>(in.getFamilyCellMap().entrySet().size());
+ long rowTimestamp = in.getTimestamp();
+ if (rowTimestamp != HConstants.LATEST_TIMESTAMP) {
+ out.setTimestamp(rowTimestamp);
+ }
+
+ for (Map.Entry<String, byte[]> attribute : in.getAttributesMap().entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(Bytes.toBytes(attribute.getKey())),
+ ByteBuffer.wrap(attribute.getValue()));
+ }
+ if (in.getDurability() != Durability.USE_DEFAULT) {
+ out.setDurability(durabilityFromHBase(in.getDurability()));
+ }
+ // Delete the whole row
+ if (in.getFamilyCellMap().size() == 0) {
+ return out;
+ }
+ TDeleteType type = null;
+ for (Map.Entry<byte[], List<Cell>> familyEntry : in.getFamilyCellMap().entrySet()) {
+ byte[] family = familyEntry.getKey();
+ TColumn column = new TColumn(ByteBuffer.wrap(familyEntry.getKey()));
+ for (Cell cell : familyEntry.getValue()) {
+ TDeleteType cellDeleteType = deleteTypeFromHBase(cell.getType());
+ if (type == null) {
+ type = cellDeleteType;
+ } else if (type != cellDeleteType) {
+ throw new RuntimeException("Only the same delete type is supported, but two delete type "
+ + "is founded, one is " + type + " the other one is " + cellDeleteType);
+ }
+ byte[] qualifier = CellUtil.cloneQualifier(cell);
+ long timestamp = cell.getTimestamp();
+ column.setFamily(family);
+ if (qualifier != null) {
+ column.setQualifier(qualifier);
+ }
+ if (timestamp != HConstants.LATEST_TIMESTAMP) {
+ column.setTimestamp(timestamp);
+ }
+ }
+ columns.add(column);
+ }
+ out.setColumns(columns);
+ out.setDeleteType(type);
+
+ return out;
+ }
+
+ /**
+ * Creates a {@link RowMutations} (HBase) from a {@link TRowMutations} (Thrift)
+ * @param in the <code>TRowMutations</code> to convert
+ * @return converted <code>RowMutations</code>
+ */
+ public static RowMutations rowMutationsFromThrift(TRowMutations in) throws IOException {
+ List<TMutation> mutations = in.getMutations();
+ RowMutations out = new RowMutations(in.getRow(), mutations.size());
+ for (TMutation mutation : mutations) {
+ if (mutation.isSetPut()) {
+ out.add(putFromThrift(mutation.getPut()));
+ }
+ if (mutation.isSetDeleteSingle()) {
+ out.add(deleteFromThrift(mutation.getDeleteSingle()));
+ }
+ }
+ return out;
+ }
+
+ public static Scan scanFromThrift(TScan in) throws IOException {
+ Scan out = new Scan();
+
+ if (in.isSetStartRow()) {
+ out.withStartRow(in.getStartRow());
+ }
+ if (in.isSetStopRow()) {
+ out.withStopRow(in.getStopRow());
+ }
+ if (in.isSetCaching()) {
+ out.setCaching(in.getCaching());
+ }
+ if (in.isSetMaxVersions()) {
+ out.readVersions(in.getMaxVersions());
+ }
+
+ if (in.isSetColumns()) {
+ for (TColumn column : in.getColumns()) {
+ if (column.isSetQualifier()) {
+ out.addColumn(column.getFamily(), column.getQualifier());
+ } else {
+ out.addFamily(column.getFamily());
+ }
+ }
+ }
+
+ TTimeRange timeRange = in.getTimeRange();
+ if (timeRange != null && timeRange.isSetMinStamp() && timeRange.isSetMaxStamp()) {
+ out.setTimeRange(timeRange.getMinStamp(), timeRange.getMaxStamp());
+ }
+
+ if (in.isSetBatchSize()) {
+ out.setBatch(in.getBatchSize());
+ }
+
+ if (in.isSetFilterString()) {
+ ParseFilter parseFilter = new ParseFilter();
+ out.setFilter(parseFilter.parseFilterString(in.getFilterString()));
+ }
+
+ if (in.isSetAttributes()) {
+ addAttributes(out, in.getAttributes());
+ }
+
+ if (in.isSetAuthorizations()) {
+ out.setAuthorizations(new Authorizations(in.getAuthorizations().getLabels()));
+ }
+
+ if (in.isSetReversed()) {
+ out.setReversed(in.isReversed());
+ }
+
+ if (in.isSetCacheBlocks()) {
+ out.setCacheBlocks(in.isCacheBlocks());
+ }
+
+ if (in.isSetColFamTimeRangeMap()) {
+ Map<ByteBuffer, TTimeRange> colFamTimeRangeMap = in.getColFamTimeRangeMap();
+ if (MapUtils.isNotEmpty(colFamTimeRangeMap)) {
+ for (Map.Entry<ByteBuffer, TTimeRange> entry : colFamTimeRangeMap.entrySet()) {
+ out.setColumnFamilyTimeRange(Bytes.toBytes(entry.getKey()),
+ entry.getValue().getMinStamp(), entry.getValue().getMaxStamp());
+ }
+ }
+ }
+
+ if (in.isSetReadType()) {
+ out.setReadType(readTypeFromThrift(in.getReadType()));
+ }
+
+ if (in.isSetLimit()) {
+ out.setLimit(in.getLimit());
+ }
+
+ if (in.isSetConsistency()) {
+ out.setConsistency(consistencyFromThrift(in.getConsistency()));
+ }
+
+ if (in.isSetTargetReplicaId()) {
+ out.setReplicaId(in.getTargetReplicaId());
+ }
+
+ if (in.isSetFilterBytes()) {
+ out.setFilter(filterFromThrift(in.getFilterBytes()));
+ }
+
+ return out;
+ }
+
+ public static byte[] filterFromHBase(Filter filter) throws IOException {
+ FilterProtos.Filter filterPB = ProtobufUtil.toFilter(filter);
+ return filterPB.toByteArray();
+ }
+
+ public static Filter filterFromThrift(byte[] filterBytes) throws IOException {
+ FilterProtos.Filter filterPB = FilterProtos.Filter.parseFrom(filterBytes);
+ return ProtobufUtil.toFilter(filterPB);
+ }
+
+ public static TScan scanFromHBase(Scan in) throws IOException {
+ TScan out = new TScan();
+ out.setStartRow(in.getStartRow());
+ out.setStopRow(in.getStopRow());
+ out.setCaching(in.getCaching());
+ out.setMaxVersions(in.getMaxVersions());
+ for (Map.Entry<byte[], NavigableSet<byte[]>> family : in.getFamilyMap().entrySet()) {
+
+ if (family.getValue() != null && !family.getValue().isEmpty()) {
+ for (byte[] qualifier : family.getValue()) {
+ TColumn column = new TColumn();
+ column.setFamily(family.getKey());
+ column.setQualifier(qualifier);
+ out.addToColumns(column);
+ }
+ } else {
+ TColumn column = new TColumn();
+ column.setFamily(family.getKey());
+ out.addToColumns(column);
+ }
+ }
+ TTimeRange tTimeRange = new TTimeRange();
+ tTimeRange.setMinStamp(in.getTimeRange().getMin()).setMaxStamp(in.getTimeRange().getMax());
+ out.setTimeRange(tTimeRange);
+ out.setBatchSize(in.getBatch());
+
+ for (Map.Entry<String, byte[]> attribute : in.getAttributesMap().entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(Bytes.toBytes(attribute.getKey())),
+ ByteBuffer.wrap(attribute.getValue()));
+ }
+
+ try {
+ Authorizations authorizations = in.getAuthorizations();
+ if (authorizations != null) {
+ TAuthorization tAuthorization = new TAuthorization();
+ tAuthorization.setLabels(authorizations.getLabels());
+ out.setAuthorizations(tAuthorization);
+ }
+ } catch (DeserializationException e) {
+ throw new RuntimeException(e);
+ }
+
+ out.setReversed(in.isReversed());
+ out.setCacheBlocks(in.getCacheBlocks());
+ out.setReadType(readTypeFromHBase(in.getReadType()));
+ out.setLimit(in.getLimit());
+ out.setConsistency(consistencyFromHBase(in.getConsistency()));
+ out.setTargetReplicaId(in.getReplicaId());
+ for (Map.Entry<byte[], TimeRange> entry : in.getColumnFamilyTimeRange().entrySet()) {
+ if (entry.getValue() != null) {
+ TTimeRange timeRange = new TTimeRange();
+ timeRange.setMinStamp(entry.getValue().getMin()).setMaxStamp(entry.getValue().getMax());
+ out.putToColFamTimeRangeMap(ByteBuffer.wrap(entry.getKey()), timeRange);
+ }
+ }
+ if (in.getFilter() != null) {
+ try {
+ out.setFilterBytes(filterFromHBase(in.getFilter()));
+ } catch (IOException ioE) {
+ throw new RuntimeException(ioE);
+ }
+ }
+ return out;
+ }
+
+ public static Increment incrementFromThrift(TIncrement in) throws IOException {
+ Increment out = new Increment(in.getRow());
+ for (TColumnIncrement column : in.getColumns()) {
+ out.addColumn(column.getFamily(), column.getQualifier(), column.getAmount());
+ }
+
+ if (in.isSetAttributes()) {
+ addAttributes(out, in.getAttributes());
+ }
+
+ if (in.isSetDurability()) {
+ out.setDurability(durabilityFromThrift(in.getDurability()));
+ }
+
+ if (in.getCellVisibility() != null) {
+ out.setCellVisibility(new CellVisibility(in.getCellVisibility().getExpression()));
+ }
+
+ if (in.isSetReturnResults()) {
+ out.setReturnResults(in.isReturnResults());
+ }
+
+ return out;
+ }
+
+ public static Append appendFromThrift(TAppend append) throws IOException {
+ Append out = new Append(append.getRow());
+ for (TColumnValue column : append.getColumns()) {
+ out.addColumn(column.getFamily(), column.getQualifier(), column.getValue());
+ }
+
+ if (append.isSetAttributes()) {
+ addAttributes(out, append.getAttributes());
+ }
+
+ if (append.isSetDurability()) {
+ out.setDurability(durabilityFromThrift(append.getDurability()));
+ }
+
+ if (append.getCellVisibility() != null) {
+ out.setCellVisibility(new CellVisibility(append.getCellVisibility().getExpression()));
+ }
+
+ if (append.isSetReturnResults()) {
+ out.setReturnResults(append.isReturnResults());
+ }
+
+ return out;
+ }
+
+ public static THRegionLocation regionLocationFromHBase(HRegionLocation hrl) {
+ RegionInfo hri = hrl.getRegion();
+ ServerName serverName = hrl.getServerName();
+
+ THRegionInfo thRegionInfo = new THRegionInfo();
+ THRegionLocation thRegionLocation = new THRegionLocation();
+ TServerName tServerName = new TServerName();
+
+ tServerName.setHostName(serverName.getHostname());
+ tServerName.setPort(serverName.getPort());
+ tServerName.setStartCode(serverName.getStartcode());
+
+ thRegionInfo.setTableName(hri.getTable().getName());
+ thRegionInfo.setEndKey(hri.getEndKey());
+ thRegionInfo.setStartKey(hri.getStartKey());
+ thRegionInfo.setOffline(hri.isOffline());
+ thRegionInfo.setSplit(hri.isSplit());
+ thRegionInfo.setReplicaId(hri.getReplicaId());
+
+ thRegionLocation.setRegionInfo(thRegionInfo);
+ thRegionLocation.setServerName(tServerName);
+
+ return thRegionLocation;
+ }
+
+ public static List<THRegionLocation> regionLocationsFromHBase(List<HRegionLocation> locations) {
+ List<THRegionLocation> tlocations = new ArrayList<>(locations.size());
+ for (HRegionLocation hrl : locations) {
+ tlocations.add(regionLocationFromHBase(hrl));
+ }
+ return tlocations;
+ }
+
+ /**
+ * Adds all the attributes into the Operation object
+ */
+ private static void addAttributes(OperationWithAttributes op,
+ Map<ByteBuffer, ByteBuffer> attributes) {
+ if (attributes == null || attributes.isEmpty()) {
+ return;
+ }
+ for (Map.Entry<ByteBuffer, ByteBuffer> entry : attributes.entrySet()) {
+ String name = Bytes.toStringBinary(getBytes(entry.getKey()));
+ byte[] value = getBytes(entry.getValue());
+ op.setAttribute(name, value);
+ }
+ }
+
+ private static Durability durabilityFromThrift(TDurability tDurability) {
+ switch (tDurability.getValue()) {
+ case 0:
+ return Durability.USE_DEFAULT;
+ case 1:
+ return Durability.SKIP_WAL;
+ case 2:
+ return Durability.ASYNC_WAL;
+ case 3:
+ return Durability.SYNC_WAL;
+ case 4:
+ return Durability.FSYNC_WAL;
+ default:
+ return Durability.USE_DEFAULT;
+ }
+ }
+
+ public static CompareOperator compareOpFromThrift(TCompareOperator tCompareOp) {
+ switch (tCompareOp.getValue()) {
+ case 0:
+ return CompareOperator.LESS;
+ case 1:
+ return CompareOperator.LESS_OR_EQUAL;
+ case 2:
+ return CompareOperator.EQUAL;
+ case 3:
+ return CompareOperator.NOT_EQUAL;
+ case 4:
+ return CompareOperator.GREATER_OR_EQUAL;
+ case 5:
+ return CompareOperator.GREATER;
+ case 6:
+ return CompareOperator.NO_OP;
+ default:
+ return null;
+ }
+ }
+
+ private static ReadType readTypeFromThrift(TReadType tReadType) {
+ switch (tReadType.getValue()) {
+ case 1:
+ return ReadType.DEFAULT;
+ case 2:
+ return ReadType.STREAM;
+ case 3:
+ return ReadType.PREAD;
+ default:
+ return null;
+ }
+ }
+
+ private static TReadType readTypeFromHBase(ReadType readType) {
+ switch (readType) {
+ case DEFAULT:
+ return TReadType.DEFAULT;
+ case STREAM:
+ return TReadType.STREAM;
+ case PREAD:
+ return TReadType.PREAD;
+ default:
+ return TReadType.DEFAULT;
+ }
+ }
+
+ private static Consistency consistencyFromThrift(TConsistency tConsistency) {
+ switch (tConsistency.getValue()) {
+ case 1:
+ return Consistency.STRONG;
+ case 2:
+ return Consistency.TIMELINE;
+ default:
+ return Consistency.STRONG;
+ }
+ }
+
+ public static TableName tableNameFromThrift(TTableName tableName) {
+ return TableName.valueOf(tableName.getNs(), tableName.getQualifier());
+ }
+
+ public static TableName[] tableNamesArrayFromThrift(List<TTableName> tableNames) {
+ TableName[] out = new TableName[tableNames.size()];
+ int index = 0;
+ for (TTableName tableName : tableNames) {
+ out[index++] = tableNameFromThrift(tableName);
+ }
+ return out;
+ }
+
+ public static List<TableName> tableNamesFromThrift(List<TTableName> tableNames) {
+ List<TableName> out = new ArrayList<>(tableNames.size());
+ for (TTableName tableName : tableNames) {
+ out.add(tableNameFromThrift(tableName));
+ }
+ return out;
+ }
+
+ public static TTableName tableNameFromHBase(TableName table) {
+ TTableName tableName = new TTableName();
+ tableName.setNs(table.getNamespace());
+ tableName.setQualifier(table.getQualifier());
+ return tableName;
+ }
+
+ public static List<TTableName> tableNamesFromHBase(List<TableName> in) {
+ List<TTableName> out = new ArrayList<>(in.size());
+ for (TableName tableName : in) {
+ out.add(tableNameFromHBase(tableName));
+ }
+ return out;
+ }
+
+ public static List<TTableName> tableNamesFromHBase(TableName[] in) {
+ List<TTableName> out = new ArrayList<>(in.length);
+ for (TableName tableName : in) {
+ out.add(tableNameFromHBase(tableName));
+ }
+ return out;
+ }
+
+ public static byte[][] splitKeyFromThrift(List<ByteBuffer> in) {
+ if (in == null || in.size() == 0) {
+ return null;
+ }
+ byte[][] out = new byte[in.size()][];
+ int index = 0;
+ for (ByteBuffer key : in) {
+ out[index++] = key.array();
+ }
+ return out;
+ }
+
+ public static BloomType bloomFilterFromThrift(TBloomFilterType in) {
+ switch (in.getValue()) {
+ case 0:
+ return BloomType.NONE;
+ case 1:
+ return BloomType.ROW;
+ case 2:
+ return BloomType.ROWCOL;
+ case 3:
+ return BloomType.ROWPREFIX_FIXED_LENGTH;
+ default:
+ return BloomType.ROW;
+ }
+ }
+
+ public static Compression.Algorithm compressionAlgorithmFromThrift(TCompressionAlgorithm in) {
+ switch (in.getValue()) {
+ case 0:
+ return Compression.Algorithm.LZO;
+ case 1:
+ return Compression.Algorithm.GZ;
+ case 2:
+ return Compression.Algorithm.NONE;
+ case 3:
+ return Compression.Algorithm.SNAPPY;
+ case 4:
+ return Compression.Algorithm.LZ4;
+ case 5:
+ return Compression.Algorithm.BZIP2;
+ case 6:
+ return Compression.Algorithm.ZSTD;
+ default:
+ return Compression.Algorithm.NONE;
+ }
+ }
+
+ public static DataBlockEncoding dataBlockEncodingFromThrift(TDataBlockEncoding in) {
+ switch (in.getValue()) {
+ case 0:
+ return DataBlockEncoding.NONE;
+ case 2:
+ return DataBlockEncoding.PREFIX;
+ case 3:
+ return DataBlockEncoding.DIFF;
+ case 4:
+ return DataBlockEncoding.FAST_DIFF;
+ case 7:
+ return DataBlockEncoding.ROW_INDEX_V1;
+ default:
+ return DataBlockEncoding.NONE;
+ }
+ }
+
+ public static KeepDeletedCells keepDeletedCellsFromThrift(TKeepDeletedCells in) {
+ switch (in.getValue()) {
+ case 0:
+ return KeepDeletedCells.FALSE;
+ case 1:
+ return KeepDeletedCells.TRUE;
+ case 2:
+ return KeepDeletedCells.TTL;
+ default:
+ return KeepDeletedCells.FALSE;
+ }
+ }
+
+ public static ColumnFamilyDescriptor
+ columnFamilyDescriptorFromThrift(TColumnFamilyDescriptor in) {
+ ColumnFamilyDescriptorBuilder builder = ColumnFamilyDescriptorBuilder.newBuilder(in.getName());
+
+ if (in.isSetAttributes()) {
+ for (Map.Entry<ByteBuffer, ByteBuffer> attribute : in.getAttributes().entrySet()) {
+ builder.setValue(attribute.getKey().array(), attribute.getValue().array());
+ }
+ }
+ if (in.isSetConfiguration()) {
+ for (Map.Entry<String, String> conf : in.getConfiguration().entrySet()) {
+ builder.setConfiguration(conf.getKey(), conf.getValue());
+ }
+ }
+ if (in.isSetBlockSize()) {
+ builder.setBlocksize(in.getBlockSize());
+ }
+ if (in.isSetBloomnFilterType()) {
+ builder.setBloomFilterType(bloomFilterFromThrift(in.getBloomnFilterType()));
+ }
+ if (in.isSetCompressionType()) {
+ builder.setCompressionType(compressionAlgorithmFromThrift(in.getCompressionType()));
+ }
+ if (in.isSetDfsReplication()) {
+ builder.setDFSReplication(in.getDfsReplication());
+ }
+ if (in.isSetDataBlockEncoding()) {
+ builder.setDataBlockEncoding(dataBlockEncodingFromThrift(in.getDataBlockEncoding()));
+ }
+ if (in.isSetKeepDeletedCells()) {
+ builder.setKeepDeletedCells(keepDeletedCellsFromThrift(in.getKeepDeletedCells()));
+ }
+ if (in.isSetMaxVersions()) {
+ builder.setMaxVersions(in.getMaxVersions());
+ }
+ if (in.isSetMinVersions()) {
+ builder.setMinVersions(in.getMinVersions());
+ }
+ if (in.isSetScope()) {
+ builder.setScope(in.getScope());
+ }
+ if (in.isSetTimeToLive()) {
+ builder.setTimeToLive(in.getTimeToLive());
+ }
+ if (in.isSetBlockCacheEnabled()) {
+ builder.setBlockCacheEnabled(in.isBlockCacheEnabled());
+ }
+ if (in.isSetCacheBloomsOnWrite()) {
+ builder.setCacheBloomsOnWrite(in.isCacheBloomsOnWrite());
+ }
+ if (in.isSetCacheDataOnWrite()) {
+ builder.setCacheDataOnWrite(in.isCacheDataOnWrite());
+ }
+ if (in.isSetCacheIndexesOnWrite()) {
+ builder.setCacheIndexesOnWrite(in.isCacheIndexesOnWrite());
+ }
+ if (in.isSetCompressTags()) {
+ builder.setCompressTags(in.isCompressTags());
+ }
+ if (in.isSetEvictBlocksOnClose()) {
+ builder.setEvictBlocksOnClose(in.isEvictBlocksOnClose());
+ }
+ if (in.isSetInMemory()) {
+ builder.setInMemory(in.isInMemory());
+ }
+
+ return builder.build();
+ }
+
+ public static NamespaceDescriptor namespaceDescriptorFromThrift(TNamespaceDescriptor in) {
+ NamespaceDescriptor.Builder builder = NamespaceDescriptor.create(in.getName());
+ if (in.isSetConfiguration()) {
+ for (Map.Entry<String, String> conf : in.getConfiguration().entrySet()) {
+ builder.addConfiguration(conf.getKey(), conf.getValue());
+ }
+ }
+ return builder.build();
+ }
+
+ public static TNamespaceDescriptor namespaceDescriptorFromHBase(NamespaceDescriptor in) {
+ TNamespaceDescriptor out = new TNamespaceDescriptor();
+ out.setName(in.getName());
+ for (Map.Entry<String, String> conf : in.getConfiguration().entrySet()) {
+ out.putToConfiguration(conf.getKey(), conf.getValue());
+ }
+ return out;
+ }
+
+ public static List<TNamespaceDescriptor> namespaceDescriptorsFromHBase(NamespaceDescriptor[] in) {
+ List<TNamespaceDescriptor> out = new ArrayList<>(in.length);
+ for (NamespaceDescriptor descriptor : in) {
+ out.add(namespaceDescriptorFromHBase(descriptor));
+ }
+ return out;
+ }
+
+ public static TableDescriptor tableDescriptorFromThrift(TTableDescriptor in) {
+ TableDescriptorBuilder builder =
+ TableDescriptorBuilder.newBuilder(tableNameFromThrift(in.getTableName()));
+ for (TColumnFamilyDescriptor column : in.getColumns()) {
+ builder.setColumnFamily(columnFamilyDescriptorFromThrift(column));
+ }
+ if (in.isSetAttributes()) {
+ for (Map.Entry<ByteBuffer, ByteBuffer> attribute : in.getAttributes().entrySet()) {
+ builder.setValue(attribute.getKey().array(), attribute.getValue().array());
+ }
+ }
+ if (in.isSetDurability()) {
+ builder.setDurability(durabilityFromThrift(in.getDurability()));
+ }
+ return builder.build();
+ }
+
+ public static List<TableDescriptor> tableDescriptorsFromThrift(List<TTableDescriptor> in) {
+ List<TableDescriptor> out = new ArrayList<>();
+ for (TTableDescriptor tableDescriptor : in) {
+ out.add(tableDescriptorFromThrift(tableDescriptor));
+ }
+ return out;
+ }
+
+ private static TDurability durabilityFromHBase(Durability durability) {
+ switch (durability) {
+ case USE_DEFAULT:
+ return TDurability.USE_DEFAULT;
+ case SKIP_WAL:
+ return TDurability.SKIP_WAL;
+ case ASYNC_WAL:
+ return TDurability.ASYNC_WAL;
+ case SYNC_WAL:
+ return TDurability.SYNC_WAL;
+ case FSYNC_WAL:
+ return TDurability.FSYNC_WAL;
+ default:
+ return null;
+ }
+ }
+
+ public static TTableDescriptor tableDescriptorFromHBase(TableDescriptor in) {
+ TTableDescriptor out = new TTableDescriptor();
+ out.setTableName(tableNameFromHBase(in.getTableName()));
+ Map<Bytes, Bytes> attributes = in.getValues();
+ for (Map.Entry<Bytes, Bytes> attribute : attributes.entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(attribute.getKey().get()),
+ ByteBuffer.wrap(attribute.getValue().get()));
+ }
+ for (ColumnFamilyDescriptor column : in.getColumnFamilies()) {
+ out.addToColumns(columnFamilyDescriptorFromHBase(column));
+ }
+ out.setDurability(durabilityFromHBase(in.getDurability()));
+ return out;
+ }
+
+ public static List<TTableDescriptor> tableDescriptorsFromHBase(List<TableDescriptor> in) {
+ List<TTableDescriptor> out = new ArrayList<>(in.size());
+ for (TableDescriptor descriptor : in) {
+ out.add(tableDescriptorFromHBase(descriptor));
+ }
+ return out;
+ }
+
+ public static List<TTableDescriptor> tableDescriptorsFromHBase(TableDescriptor[] in) {
+ List<TTableDescriptor> out = new ArrayList<>(in.length);
+ for (TableDescriptor descriptor : in) {
+ out.add(tableDescriptorFromHBase(descriptor));
+ }
+ return out;
+ }
+
+ public static TBloomFilterType bloomFilterFromHBase(BloomType in) {
+ switch (in) {
+ case NONE:
+ return TBloomFilterType.NONE;
+ case ROW:
+ return TBloomFilterType.ROW;
+ case ROWCOL:
+ return TBloomFilterType.ROWCOL;
+ case ROWPREFIX_FIXED_LENGTH:
+ return TBloomFilterType.ROWPREFIX_FIXED_LENGTH;
+ default:
+ return TBloomFilterType.ROW;
+ }
+ }
+
+ public static TCompressionAlgorithm compressionAlgorithmFromHBase(Compression.Algorithm in) {
+ switch (in) {
+ case LZO:
+ return TCompressionAlgorithm.LZO;
+ case GZ:
+ return TCompressionAlgorithm.GZ;
+ case NONE:
+ return TCompressionAlgorithm.NONE;
+ case SNAPPY:
+ return TCompressionAlgorithm.SNAPPY;
+ case LZ4:
+ return TCompressionAlgorithm.LZ4;
+ case BZIP2:
+ return TCompressionAlgorithm.BZIP2;
+ case ZSTD:
+ return TCompressionAlgorithm.ZSTD;
+ default:
+ return TCompressionAlgorithm.NONE;
+ }
+ }
+
+ public static TDataBlockEncoding dataBlockEncodingFromHBase(DataBlockEncoding in) {
+ switch (in) {
+ case NONE:
+ return TDataBlockEncoding.NONE;
+ case PREFIX:
+ return TDataBlockEncoding.PREFIX;
+ case DIFF:
+ return TDataBlockEncoding.DIFF;
+ case FAST_DIFF:
+ return TDataBlockEncoding.FAST_DIFF;
+ case ROW_INDEX_V1:
+ return TDataBlockEncoding.ROW_INDEX_V1;
+ default:
+ return TDataBlockEncoding.NONE;
+ }
+ }
+
+ public static TKeepDeletedCells keepDeletedCellsFromHBase(KeepDeletedCells in) {
+ switch (in) {
+ case FALSE:
+ return TKeepDeletedCells.FALSE;
+ case TRUE:
+ return TKeepDeletedCells.TRUE;
+ case TTL:
+ return TKeepDeletedCells.TTL;
+ default:
+ return TKeepDeletedCells.FALSE;
+ }
+ }
+
+ public static TColumnFamilyDescriptor columnFamilyDescriptorFromHBase(ColumnFamilyDescriptor in) {
+ TColumnFamilyDescriptor out = new TColumnFamilyDescriptor();
+ out.setName(in.getName());
+ for (Map.Entry<Bytes, Bytes> attribute : in.getValues().entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(attribute.getKey().get()),
+ ByteBuffer.wrap(attribute.getValue().get()));
+ }
+ for (Map.Entry<String, String> conf : in.getConfiguration().entrySet()) {
+ out.putToConfiguration(conf.getKey(), conf.getValue());
+ }
+ out.setBlockSize(in.getBlocksize());
+ out.setBloomnFilterType(bloomFilterFromHBase(in.getBloomFilterType()));
+ out.setCompressionType(compressionAlgorithmFromHBase(in.getCompressionType()));
+ out.setDfsReplication(in.getDFSReplication());
+ out.setDataBlockEncoding(dataBlockEncodingFromHBase(in.getDataBlockEncoding()));
+ out.setKeepDeletedCells(keepDeletedCellsFromHBase(in.getKeepDeletedCells()));
+ out.setMaxVersions(in.getMaxVersions());
+ out.setMinVersions(in.getMinVersions());
+ out.setScope(in.getScope());
+ out.setTimeToLive(in.getTimeToLive());
+ out.setBlockCacheEnabled(in.isBlockCacheEnabled());
+ out.setCacheBloomsOnWrite(in.isCacheBloomsOnWrite());
+ out.setCacheDataOnWrite(in.isCacheDataOnWrite());
+ out.setCacheIndexesOnWrite(in.isCacheIndexesOnWrite());
+ out.setCompressTags(in.isCompressTags());
+ out.setEvictBlocksOnClose(in.isEvictBlocksOnClose());
+ out.setInMemory(in.isInMemory());
+ return out;
+ }
+
+ private static TConsistency consistencyFromHBase(Consistency consistency) {
+ switch (consistency) {
+ case STRONG:
+ return TConsistency.STRONG;
+ case TIMELINE:
+ return TConsistency.TIMELINE;
+ default:
+ return TConsistency.STRONG;
+ }
+ }
+
+ public static TGet getFromHBase(Get in) {
+ TGet out = new TGet();
+ out.setRow(in.getRow());
+
+ TTimeRange tTimeRange = new TTimeRange();
+ tTimeRange.setMaxStamp(in.getTimeRange().getMax()).setMinStamp(in.getTimeRange().getMin());
+ out.setTimeRange(tTimeRange);
+ out.setMaxVersions(in.getMaxVersions());
+
+ for (Map.Entry<String, byte[]> attribute : in.getAttributesMap().entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(Bytes.toBytes(attribute.getKey())),
+ ByteBuffer.wrap(attribute.getValue()));
+ }
+ try {
+ Authorizations authorizations = in.getAuthorizations();
+ if (authorizations != null) {
+ TAuthorization tAuthorization = new TAuthorization();
+ tAuthorization.setLabels(authorizations.getLabels());
+ out.setAuthorizations(tAuthorization);
+ }
+ } catch (DeserializationException e) {
+ throw new RuntimeException(e);
+ }
+ out.setConsistency(consistencyFromHBase(in.getConsistency()));
+ out.setTargetReplicaId(in.getReplicaId());
+ out.setCacheBlocks(in.getCacheBlocks());
+ out.setStoreLimit(in.getMaxResultsPerColumnFamily());
+ out.setStoreOffset(in.getRowOffsetPerColumnFamily());
+ out.setExistence_only(in.isCheckExistenceOnly());
+ for (Map.Entry<byte[], NavigableSet<byte[]>> family : in.getFamilyMap().entrySet()) {
+
+ if (family.getValue() != null && !family.getValue().isEmpty()) {
+ for (byte[] qualifier : family.getValue()) {
+ TColumn column = new TColumn();
+ column.setFamily(family.getKey());
+ column.setQualifier(qualifier);
+ out.addToColumns(column);
+ }
+ } else {
+ TColumn column = new TColumn();
+ column.setFamily(family.getKey());
+ out.addToColumns(column);
+ }
+ }
+ if (in.getFilter() != null) {
+ try {
+ out.setFilterBytes(filterFromHBase(in.getFilter()));
+ } catch (IOException ioE) {
+ throw new RuntimeException(ioE);
+ }
+ }
+ return out;
+ }
+
+ public static Cell toCell(ExtendedCellBuilder cellBuilder, byte[] row, TColumnValue columnValue) {
+ return cellBuilder.clear().setRow(row).setFamily(columnValue.getFamily())
+ .setQualifier(columnValue.getQualifier()).setTimestamp(columnValue.getTimestamp())
+ .setType(columnValue.getType()).setValue(columnValue.getValue())
+ .setTags(columnValue.getTags()).build();
+ }
+
+ public static Result resultFromThrift(TResult in) {
+ if (in == null) {
+ return null;
+ }
+ if (!in.isSetColumnValues() || in.getColumnValues().isEmpty()) {
+ return in.isStale() ? EMPTY_RESULT_STALE : EMPTY_RESULT;
+ }
+ List<Cell> cells = new ArrayList<>(in.getColumnValues().size());
+ ExtendedCellBuilder builder = ExtendedCellBuilderFactory.create(CellBuilderType.SHALLOW_COPY);
+ for (TColumnValue columnValue : in.getColumnValues()) {
+ cells.add(toCell(builder, in.getRow(), columnValue));
+ }
+ return Result.create(cells, null, in.isStale(), in.isPartial());
+ }
+
+ public static TPut putFromHBase(Put in) {
+ TPut out = new TPut();
+ out.setRow(in.getRow());
+ if (in.getTimestamp() != HConstants.LATEST_TIMESTAMP) {
+ out.setTimestamp(in.getTimestamp());
+ }
+ if (in.getDurability() != Durability.USE_DEFAULT) {
+ out.setDurability(durabilityFromHBase(in.getDurability()));
+ }
+ for (Map.Entry<byte[], List<Cell>> entry : in.getFamilyCellMap().entrySet()) {
+ byte[] family = entry.getKey();
+ for (Cell cell : entry.getValue()) {
+ TColumnValue columnValue = new TColumnValue();
+ columnValue.setFamily(family).setQualifier(CellUtil.cloneQualifier(cell))
+ .setType(cell.getType().getCode()).setTimestamp(cell.getTimestamp())
+ .setValue(CellUtil.cloneValue(cell));
+ if (cell.getTagsLength() != 0) {
+ columnValue.setTags(PrivateCellUtil.cloneTags(cell));
+ }
+ out.addToColumnValues(columnValue);
+ }
+ }
+ for (Map.Entry<String, byte[]> attribute : in.getAttributesMap().entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(Bytes.toBytes(attribute.getKey())),
+ ByteBuffer.wrap(attribute.getValue()));
+ }
+ try {
+ CellVisibility cellVisibility = in.getCellVisibility();
+ if (cellVisibility != null) {
+ TCellVisibility tCellVisibility = new TCellVisibility();
+ tCellVisibility.setExpression(cellVisibility.getExpression());
+ out.setCellVisibility(tCellVisibility);
+ }
+ } catch (DeserializationException e) {
+ throw new RuntimeException(e);
+ }
+ return out;
+ }
+
+ public static List<TPut> putsFromHBase(List<Put> in) {
+ List<TPut> out = new ArrayList<>(in.size());
+ for (Put put : in) {
+ out.add(putFromHBase(put));
+ }
+ return out;
+ }
+
+ public static NamespaceDescriptor[]
+ namespaceDescriptorsFromThrift(List<TNamespaceDescriptor> in) {
+ NamespaceDescriptor[] out = new NamespaceDescriptor[in.size()];
+ int index = 0;
+ for (TNamespaceDescriptor descriptor : in) {
+ out[index++] = namespaceDescriptorFromThrift(descriptor);
+ }
+ return out;
+ }
+
+ public static List<TDelete> deletesFromHBase(List<Delete> in) {
+ List<TDelete> out = new ArrayList<>(in.size());
+ for (Delete delete : in) {
+ out.add(deleteFromHBase(delete));
+ }
+ return out;
+ }
+
+ public static TAppend appendFromHBase(Append in) throws IOException {
+ TAppend out = new TAppend();
+ out.setRow(in.getRow());
+
+ if (in.getDurability() != Durability.USE_DEFAULT) {
+ out.setDurability(durabilityFromHBase(in.getDurability()));
+ }
+ for (Map.Entry<byte[], List<Cell>> entry : in.getFamilyCellMap().entrySet()) {
+ byte[] family = entry.getKey();
+ for (Cell cell : entry.getValue()) {
+ TColumnValue columnValue = new TColumnValue();
+ columnValue.setFamily(family).setQualifier(CellUtil.cloneQualifier(cell))
+ .setType(cell.getType().getCode()).setTimestamp(cell.getTimestamp())
+ .setValue(CellUtil.cloneValue(cell));
+ if (cell.getTagsLength() != 0) {
+ columnValue.setTags(PrivateCellUtil.cloneTags(cell));
+ }
+ out.addToColumns(columnValue);
+ }
+ }
+ for (Map.Entry<String, byte[]> attribute : in.getAttributesMap().entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(Bytes.toBytes(attribute.getKey())),
+ ByteBuffer.wrap(attribute.getValue()));
+ }
+ try {
+ CellVisibility cellVisibility = in.getCellVisibility();
+ if (cellVisibility != null) {
+ TCellVisibility tCellVisibility = new TCellVisibility();
+ tCellVisibility.setExpression(cellVisibility.getExpression());
+ out.setCellVisibility(tCellVisibility);
+ }
+ } catch (DeserializationException e) {
+ throw new RuntimeException(e);
+ }
+ out.setReturnResults(in.isReturnResults());
+ return out;
+ }
+
+ public static TIncrement incrementFromHBase(Increment in) throws IOException {
+ TIncrement out = new TIncrement();
+ out.setRow(in.getRow());
+
+ if (in.getDurability() != Durability.USE_DEFAULT) {
+ out.setDurability(durabilityFromHBase(in.getDurability()));
+ }
+ for (Map.Entry<byte[], List<Cell>> entry : in.getFamilyCellMap().entrySet()) {
+ byte[] family = entry.getKey();
+ for (Cell cell : entry.getValue()) {
+ TColumnIncrement columnValue = new TColumnIncrement();
+ columnValue.setFamily(family).setQualifier(CellUtil.cloneQualifier(cell));
+ columnValue.setAmount(
+ Bytes.toLong(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));
+ out.addToColumns(columnValue);
+ }
+ }
+ for (Map.Entry<String, byte[]> attribute : in.getAttributesMap().entrySet()) {
+ out.putToAttributes(ByteBuffer.wrap(Bytes.toBytes(attribute.getKey())),
+ ByteBuffer.wrap(attribute.getValue()));
+ }
+ try {
+ CellVisibility cellVisibility = in.getCellVisibility();
+ if (cellVisibility != null) {
+ TCellVisibility tCellVisibility = new TCellVisibility();
+ tCellVisibility.setExpression(cellVisibility.getExpression());
+ out.setCellVisibility(tCellVisibility);
+ }
+ } catch (DeserializationException e) {
+ throw new RuntimeException(e);
+ }
+ out.setReturnResults(in.isReturnResults());
+ return out;
+ }
+
+ public static TRowMutations rowMutationsFromHBase(RowMutations in) {
+ TRowMutations tRowMutations = new TRowMutations();
+ tRowMutations.setRow(in.getRow());
+ for (Mutation mutation : in.getMutations()) {
+ TMutation tMutation = new TMutation();
+ if (mutation instanceof Put) {
+ tMutation.setPut(ThriftUtilities.putFromHBase((Put) mutation));
+ } else if (mutation instanceof Delete) {
+ tMutation.setDeleteSingle(ThriftUtilities.deleteFromHBase((Delete) mutation));
+ } else {
+ throw new IllegalArgumentException(
+ "Only Put and Delete is supported in mutateRow, but muation=" + mutation);
+ }
+ tRowMutations.addToMutations(tMutation);
+ }
+ return tRowMutations;
+ }
+
+ public static TCompareOperator compareOpFromHBase(CompareOperator compareOp) {
+ switch (compareOp) {
+ case LESS:
+ return TCompareOperator.LESS;
+ case LESS_OR_EQUAL:
+ return TCompareOperator.LESS_OR_EQUAL;
+ case EQUAL:
+ return TCompareOperator.EQUAL;
+ case NOT_EQUAL:
+ return TCompareOperator.NOT_EQUAL;
+ case GREATER_OR_EQUAL:
+ return TCompareOperator.GREATER_OR_EQUAL;
+ case GREATER:
+ return TCompareOperator.GREATER;
+ case NO_OP:
+ return TCompareOperator.NO_OP;
+ default:
+ return null;
+ }
+ }
+
+ public static List<ByteBuffer> splitKeyFromHBase(byte[][] in) {
+ if (in == null || in.length == 0) {
+ return null;
+ }
+ List<ByteBuffer> out = new ArrayList<>(in.length);
+ for (byte[] key : in) {
+ out.add(ByteBuffer.wrap(key));
+ }
+ return out;
+ }
+
+ public static Result[] resultsFromThrift(List<TResult> in) {
+ Result[] out = new Result[in.size()];
+ int index = 0;
+ for (TResult tResult : in) {
+ out[index++] = resultFromThrift(tResult);
+ }
+ return out;
+ }
+
+ public static List<TGet> getsFromHBase(List<Get> in) {
+ List<TGet> out = new ArrayList<>(in.size());
+ for (Get get : in) {
+ out.add(getFromHBase(get));
+ }
+ return out;
+ }
+
+ public static Set<TServerName> getServerNamesFromHBase(Set<ServerName> serverNames) {
+ if (CollectionUtils.isEmpty(serverNames)) {
+ return Collections.emptySet();
+ }
+ return serverNames.stream().map(serverName -> {
+ TServerName tServerName = new TServerName();
+ tServerName.setHostName(serverName.getHostname());
+ tServerName.setPort(serverName.getPort());
+ tServerName.setStartCode(serverName.getStartcode());
+ return tServerName;
+ }).collect(Collectors.toSet());
+ }
+
+ public static Set<ServerName> getServerNamesFromThrift(Set<TServerName> tServerNames) {
+ if (CollectionUtils.isEmpty(tServerNames)) {
+ return Collections.emptySet();
+ }
+ return tServerNames.stream().map(tServerName -> ServerName.valueOf(tServerName.getHostName(),
+ tServerName.getPort(), tServerName.getStartCode())).collect(Collectors.toSet());
+ }
+
+ public static TLogQueryFilter getSlowLogQueryFromHBase(LogQueryFilter logQueryFilter) {
+ TLogQueryFilter tLogQueryFilter = new TLogQueryFilter();
+ tLogQueryFilter.setRegionName(logQueryFilter.getRegionName());
+ tLogQueryFilter.setClientAddress(logQueryFilter.getClientAddress());
+ tLogQueryFilter.setTableName(logQueryFilter.getTableName());
+ tLogQueryFilter.setUserName(logQueryFilter.getUserName());
+ tLogQueryFilter.setLimit(logQueryFilter.getLimit());
+ TLogType tLogType = gettLogTypeFromHBase(logQueryFilter);
+ tLogQueryFilter.setLogType(tLogType);
+ TFilterByOperator tFilterByOperator = getTFilterByFromHBase(logQueryFilter);
+ tLogQueryFilter.setFilterByOperator(tFilterByOperator);
+ return tLogQueryFilter;
+ }
+
+ private static TLogType gettLogTypeFromHBase(final LogQueryFilter logQueryFilter) {
+ TLogType tLogType;
+ switch (logQueryFilter.getType()) {
+ case SLOW_LOG: {
+ tLogType = TLogType.SLOW_LOG;
+ break;
+ }
+ case LARGE_LOG: {
+ tLogType = TLogType.LARGE_LOG;
+ break;
+ }
+ default: {
+ tLogType = TLogType.SLOW_LOG;
+ }
+ }
+ return tLogType;
+ }
+
+ private static TFilterByOperator getTFilterByFromHBase(final LogQueryFilter logQueryFilter) {
+ TFilterByOperator tFilterByOperator;
+ switch (logQueryFilter.getFilterByOperator()) {
+ case AND: {
+ tFilterByOperator = TFilterByOperator.AND;
+ break;
+ }
+ case OR: {
+ tFilterByOperator = TFilterByOperator.OR;
+ break;
+ }
+ default: {
+ tFilterByOperator = TFilterByOperator.OR;
+ }
+ }
+ return tFilterByOperator;
+ }
+
+ public static LogQueryFilter getSlowLogQueryFromThrift(TLogQueryFilter tLogQueryFilter) {
+ LogQueryFilter logQueryFilter = new LogQueryFilter();
+ logQueryFilter.setRegionName(tLogQueryFilter.getRegionName());
+ logQueryFilter.setClientAddress(tLogQueryFilter.getClientAddress());
+ logQueryFilter.setTableName(tLogQueryFilter.getTableName());
+ logQueryFilter.setUserName(tLogQueryFilter.getUserName());
+ logQueryFilter.setLimit(tLogQueryFilter.getLimit());
+ LogQueryFilter.Type type = getLogTypeFromThrift(tLogQueryFilter);
+ logQueryFilter.setType(type);
+ LogQueryFilter.FilterByOperator filterByOperator = getFilterByFromThrift(tLogQueryFilter);
+ logQueryFilter.setFilterByOperator(filterByOperator);
+ return logQueryFilter;
+ }
+
+ private static LogQueryFilter.Type
+ getLogTypeFromThrift(final TLogQueryFilter tSlowLogQueryFilter) {
+ LogQueryFilter.Type type;
+ switch (tSlowLogQueryFilter.getLogType()) {
+ case SLOW_LOG: {
+ type = LogQueryFilter.Type.SLOW_LOG;
+ break;
+ }
+ case LARGE_LOG: {
+ type = LogQueryFilter.Type.LARGE_LOG;
+ break;
+ }
+ default: {
+ type = LogQueryFilter.Type.SLOW_LOG;
+ }
+ }
+ return type;
+ }
+
+ private static LogQueryFilter.FilterByOperator
+ getFilterByFromThrift(final TLogQueryFilter tLogQueryFilter) {
+ LogQueryFilter.FilterByOperator filterByOperator;
+ switch (tLogQueryFilter.getFilterByOperator()) {
+ case AND: {
+ filterByOperator = LogQueryFilter.FilterByOperator.AND;
+ break;
+ }
+ case OR: {
+ filterByOperator = LogQueryFilter.FilterByOperator.OR;
+ break;
+ }
+ default: {
+ filterByOperator = LogQueryFilter.FilterByOperator.OR;
+ }
+ }
+ return filterByOperator;
+ }
+
+ public static List<TOnlineLogRecord>
+ getSlowLogRecordsFromHBase(List<OnlineLogRecord> onlineLogRecords) {
+ if (CollectionUtils.isEmpty(onlineLogRecords)) {
+ return Collections.emptyList();
+ }
+ return onlineLogRecords.stream().map(slowLogRecord -> {
+ TOnlineLogRecord tOnlineLogRecord = new TOnlineLogRecord();
+ tOnlineLogRecord.setCallDetails(slowLogRecord.getCallDetails());
+ tOnlineLogRecord.setClientAddress(slowLogRecord.getClientAddress());
+ tOnlineLogRecord.setMethodName(slowLogRecord.getMethodName());
+ tOnlineLogRecord.setMultiGetsCount(slowLogRecord.getMultiGetsCount());
+ tOnlineLogRecord.setMultiMutationsCount(slowLogRecord.getMultiMutationsCount());
+ tOnlineLogRecord.setMultiServiceCalls(slowLogRecord.getMultiServiceCalls());
+ tOnlineLogRecord.setParam(slowLogRecord.getParam());
+ tOnlineLogRecord.setProcessingTime(slowLogRecord.getProcessingTime());
+ tOnlineLogRecord.setQueueTime(slowLogRecord.getQueueTime());
+ tOnlineLogRecord.setRegionName(slowLogRecord.getRegionName());
+ tOnlineLogRecord.setResponseSize(slowLogRecord.getResponseSize());
+ tOnlineLogRecord.setServerClass(slowLogRecord.getServerClass());
+ tOnlineLogRecord.setStartTime(slowLogRecord.getStartTime());
+ tOnlineLogRecord.setUserName(slowLogRecord.getUserName());
+ return tOnlineLogRecord;
+ }).collect(Collectors.toList());
+ }
+
+ public static List<OnlineLogRecord>
+ getSlowLogRecordsFromThrift(List<TOnlineLogRecord> tOnlineLogRecords) {
+ if (CollectionUtils.isEmpty(tOnlineLogRecords)) {
+ return Collections.emptyList();
+ }
+ return tOnlineLogRecords.stream()
+ .map(tSlowLogRecord -> new OnlineLogRecord.OnlineLogRecordBuilder()
+ .setCallDetails(tSlowLogRecord.getCallDetails())
+ .setClientAddress(tSlowLogRecord.getClientAddress())
+ .setMethodName(tSlowLogRecord.getMethodName())
+ .setMultiGetsCount(tSlowLogRecord.getMultiGetsCount())
+ .setMultiMutationsCount(tSlowLogRecord.getMultiMutationsCount())
+ .setMultiServiceCalls(tSlowLogRecord.getMultiServiceCalls())
+ .setParam(tSlowLogRecord.getParam()).setProcessingTime(tSlowLogRecord.getProcessingTime())
+ .setQueueTime(tSlowLogRecord.getQueueTime()).setRegionName(tSlowLogRecord.getRegionName())
+ .setResponseSize(tSlowLogRecord.getResponseSize())
+ .setServerClass(tSlowLogRecord.getServerClass()).setStartTime(tSlowLogRecord.getStartTime())
+ .setUserName(tSlowLogRecord.getUserName()).build())
+ .collect(Collectors.toList());
+ }
+
+ public static Permission.Action[] permissionActionsFromString(String permission_actions) {
+ Set<Permission.Action> actions = new HashSet<>();
+ for (char c : permission_actions.toCharArray()) {
+ switch (c) {
+ case 'R':
+ actions.add(Permission.Action.READ);
+ break;
+ case 'W':
+ actions.add(Permission.Action.WRITE);
+ break;
+ case 'C':
+ actions.add(Permission.Action.CREATE);
+ break;
+ case 'X':
+ actions.add(Permission.Action.EXEC);
+ break;
+ case 'A':
+ actions.add(Permission.Action.ADMIN);
+ break;
+ default:
+ break;
+ }
+ }
+ return actions.toArray(new Permission.Action[0]);
+ }
+
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftAdmin.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftAdmin.java
new file mode 100644
index 0000000..13a1b99
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftAdmin.java
@@ -0,0 +1,1317 @@
+/*
+ * 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.thrift2.client;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Future;
+import java.util.regex.Pattern;
+import org.apache.commons.lang3.NotImplementedException;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.CacheEvictionStats;
+import org.apache.hadoop.hbase.ClusterMetrics;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.NamespaceDescriptor;
+import org.apache.hadoop.hbase.NamespaceNotFoundException;
+import org.apache.hadoop.hbase.RegionMetrics;
+import org.apache.hadoop.hbase.ServerName;
+import org.apache.hadoop.hbase.TableExistsException;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.TableNotFoundException;
+import org.apache.hadoop.hbase.client.Admin;
+import org.apache.hadoop.hbase.client.BalanceRequest;
+import org.apache.hadoop.hbase.client.BalanceResponse;
+import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.client.CompactType;
+import org.apache.hadoop.hbase.client.CompactionState;
+import org.apache.hadoop.hbase.client.Connection;
+import org.apache.hadoop.hbase.client.LogEntry;
+import org.apache.hadoop.hbase.client.LogQueryFilter;
+import org.apache.hadoop.hbase.client.NormalizeTableFilterParams;
+import org.apache.hadoop.hbase.client.OnlineLogRecord;
+import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.ServerType;
+import org.apache.hadoop.hbase.client.SnapshotDescription;
+import org.apache.hadoop.hbase.client.SnapshotType;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.client.replication.TableCFs;
+import org.apache.hadoop.hbase.client.security.SecurityCapability;
+import org.apache.hadoop.hbase.ipc.CoprocessorRpcChannel;
+import org.apache.hadoop.hbase.net.Address;
+import org.apache.hadoop.hbase.quotas.QuotaFilter;
+import org.apache.hadoop.hbase.quotas.QuotaSettings;
+import org.apache.hadoop.hbase.quotas.SpaceQuotaSnapshot;
+import org.apache.hadoop.hbase.replication.ReplicationPeerConfig;
+import org.apache.hadoop.hbase.replication.ReplicationPeerDescription;
+import org.apache.hadoop.hbase.replication.SyncReplicationState;
+import org.apache.hadoop.hbase.rsgroup.RSGroupInfo;
+import org.apache.hadoop.hbase.security.access.GetUserPermissionsRequest;
+import org.apache.hadoop.hbase.security.access.Permission;
+import org.apache.hadoop.hbase.security.access.UserPermission;
+import org.apache.hadoop.hbase.snapshot.RestoreSnapshotException;
+import org.apache.hadoop.hbase.thrift2.ThriftUtilities;
+import org.apache.hadoop.hbase.thrift2.generated.TColumnFamilyDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.THBaseService;
+import org.apache.hadoop.hbase.thrift2.generated.TLogQueryFilter;
+import org.apache.hadoop.hbase.thrift2.generated.TNamespaceDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TOnlineLogRecord;
+import org.apache.hadoop.hbase.thrift2.generated.TServerName;
+import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor;
+import org.apache.hadoop.hbase.thrift2.generated.TTableName;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.hadoop.hbase.util.Pair;
+import org.apache.thrift.TException;
+import org.apache.thrift.transport.TTransport;
+import org.apache.yetus.audience.InterfaceAudience;
+
+@InterfaceAudience.Private
+public class ThriftAdmin implements Admin {
+
+ private THBaseService.Client client;
+ private TTransport transport;
+ private int operationTimeout;
+ private int syncWaitTimeout;
+ private Configuration conf;
+
+ public ThriftAdmin(THBaseService.Client client, TTransport tTransport, Configuration conf) {
+ this.client = client;
+ this.transport = tTransport;
+ this.operationTimeout = conf.getInt(HConstants.HBASE_CLIENT_OPERATION_TIMEOUT,
+ HConstants.DEFAULT_HBASE_CLIENT_OPERATION_TIMEOUT);
+ this.syncWaitTimeout = conf.getInt("hbase.client.sync.wait.timeout.msec", 10 * 60000); // 10min
+ this.conf = conf;
+ }
+
+ @Override
+ public int getOperationTimeout() {
+ return operationTimeout;
+ }
+
+ @Override
+ public int getSyncWaitTimeout() {
+ return syncWaitTimeout;
+ }
+
+ @Override
+ public void abort(String why, Throwable e) {
+ }
+
+ @Override
+ public boolean isAborted() {
+ return false;
+ }
+
+ @Override
+ public void close() {
+ transport.close();
+ }
+
+ @Override
+ public Configuration getConfiguration() {
+ return conf;
+ }
+
+ @Override
+ public boolean tableExists(TableName tableName) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ return client.tableExists(tTableName);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public Connection getConnection() {
+ throw new NotImplementedException("getConnection not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<TableDescriptor> listTableDescriptors() throws IOException {
+ return listTableDescriptors((Pattern) null);
+ }
+
+ @Override
+ public List<TableDescriptor> listTableDescriptors(boolean includeSysTables) throws IOException {
+ return listTableDescriptors(null, includeSysTables);
+ }
+
+ @Override
+ public List<TableDescriptor> listTableDescriptors(Pattern pattern) throws IOException {
+ return listTableDescriptors(pattern, false);
+ }
+
+ @Override
+ public List<TableDescriptor> listTableDescriptors(Pattern pattern, boolean includeSysTables)
+ throws IOException {
+ try {
+ String regex = (pattern == null ? null : pattern.toString());
+ List<TTableDescriptor> tTableDescriptors =
+ client.getTableDescriptorsByPattern(regex, includeSysTables);
+ return ThriftUtilities.tableDescriptorsFromThrift(tTableDescriptors);
+
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public TableName[] listTableNames() throws IOException {
+ return listTableNames(null);
+ }
+
+ @Override
+ public TableName[] listTableNames(Pattern pattern) throws IOException {
+ return listTableNames(pattern, false);
+ }
+
+ @Override
+ public TableName[] listTableNames(Pattern pattern, boolean includeSysTables) throws IOException {
+ String regex = (pattern == null ? null : pattern.toString());
+ try {
+ List<TTableName> tTableNames = client.getTableNamesByPattern(regex, includeSysTables);
+ return ThriftUtilities.tableNamesArrayFromThrift(tTableNames);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public TableDescriptor getDescriptor(TableName tableName)
+ throws TableNotFoundException, IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ TTableDescriptor tTableDescriptor = client.getTableDescriptor(tTableName);
+ return ThriftUtilities.tableDescriptorFromThrift(tTableDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public List<TableDescriptor> listTableDescriptorsByNamespace(byte[] name) throws IOException {
+ try {
+ List<TTableDescriptor> tTableDescriptors =
+ client.getTableDescriptorsByNamespace(Bytes.toString(name));
+ return ThriftUtilities.tableDescriptorsFromThrift(tTableDescriptors);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public TableName[] listTableNamesByNamespace(String name) throws IOException {
+ try {
+ List<TTableName> tTableNames = client.getTableNamesByNamespace(name);
+ return ThriftUtilities.tableNamesArrayFromThrift(tTableNames);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void createTable(TableDescriptor desc) throws IOException {
+ createTable(desc, null);
+ }
+
+ @Override
+ public void createTable(TableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions)
+ throws IOException {
+ if (numRegions < 3) {
+ throw new IllegalArgumentException("Must create at least three regions");
+ } else if (Bytes.compareTo(startKey, endKey) >= 0) {
+ throw new IllegalArgumentException("Start key must be smaller than end key");
+ }
+ if (numRegions == 3) {
+ createTable(desc, new byte[][] { startKey, endKey });
+ return;
+ }
+ byte[][] splitKeys = Bytes.split(startKey, endKey, numRegions - 3);
+ if (splitKeys == null || splitKeys.length != numRegions - 1) {
+ throw new IllegalArgumentException("Unable to split key range into enough regions");
+ }
+ createTable(desc, splitKeys);
+ }
+
+ @Override
+ public void createTable(TableDescriptor desc, byte[][] splitKeys) throws IOException {
+ TTableDescriptor tTableDescriptor = ThriftUtilities.tableDescriptorFromHBase(desc);
+ List<ByteBuffer> splitKeyInBuffer = ThriftUtilities.splitKeyFromHBase(splitKeys);
+ try {
+ client.createTable(tTableDescriptor, splitKeyInBuffer);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void deleteTable(TableName tableName) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ client.deleteTable(tTableName);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void truncateTable(TableName tableName, boolean preserveSplits) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ client.truncateTable(tTableName, preserveSplits);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void enableTable(TableName tableName) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ client.enableTable(tTableName);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void disableTable(TableName tableName) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ client.disableTable(tTableName);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public boolean isTableEnabled(TableName tableName) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ return client.isTableEnabled(tTableName);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public boolean isTableDisabled(TableName tableName) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ return client.isTableDisabled(tTableName);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public boolean isTableAvailable(TableName tableName) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ return client.isTableAvailable(tTableName);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void addColumnFamily(TableName tableName, ColumnFamilyDescriptor columnFamily)
+ throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ TColumnFamilyDescriptor tColumnFamilyDescriptor =
+ ThriftUtilities.columnFamilyDescriptorFromHBase(columnFamily);
+ try {
+ client.addColumnFamily(tTableName, tColumnFamilyDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void deleteColumnFamily(TableName tableName, byte[] columnFamily) throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ try {
+ client.deleteColumnFamily(tTableName, ByteBuffer.wrap(columnFamily));
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void modifyColumnFamily(TableName tableName, ColumnFamilyDescriptor columnFamily)
+ throws IOException {
+ TTableName tTableName = ThriftUtilities.tableNameFromHBase(tableName);
+ TColumnFamilyDescriptor tColumnFamilyDescriptor =
+ ThriftUtilities.columnFamilyDescriptorFromHBase(columnFamily);
+ try {
+ client.modifyColumnFamily(tTableName, tColumnFamilyDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void modifyTable(TableDescriptor td) throws IOException {
+ TTableDescriptor tTableDescriptor = ThriftUtilities.tableDescriptorFromHBase(td);
+ try {
+ client.modifyTable(tTableDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void modifyNamespace(NamespaceDescriptor descriptor) throws IOException {
+ TNamespaceDescriptor tNamespaceDescriptor =
+ ThriftUtilities.namespaceDescriptorFromHBase(descriptor);
+ try {
+ client.modifyNamespace(tNamespaceDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void deleteNamespace(String name) throws IOException {
+ try {
+ client.deleteNamespace(name);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public NamespaceDescriptor getNamespaceDescriptor(String name)
+ throws NamespaceNotFoundException, IOException {
+ try {
+ TNamespaceDescriptor tNamespaceDescriptor = client.getNamespaceDescriptor(name);
+ return ThriftUtilities.namespaceDescriptorFromThrift(tNamespaceDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public String[] listNamespaces() throws IOException {
+ try {
+ List<String> tNamespaces = client.listNamespaces();
+ return tNamespaces.toArray(new String[tNamespaces.size()]);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public NamespaceDescriptor[] listNamespaceDescriptors() throws IOException {
+ try {
+ List<TNamespaceDescriptor> tNamespaceDescriptors = client.listNamespaceDescriptors();
+ return ThriftUtilities.namespaceDescriptorsFromThrift(tNamespaceDescriptors);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void createNamespace(NamespaceDescriptor descriptor) throws IOException {
+ TNamespaceDescriptor tNamespaceDescriptor =
+ ThriftUtilities.namespaceDescriptorFromHBase(descriptor);
+ try {
+ client.createNamespace(tNamespaceDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public boolean switchRpcThrottle(boolean enable) throws IOException {
+ throw new NotImplementedException("switchRpcThrottle by pattern not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isRpcThrottleEnabled() throws IOException {
+ throw new NotImplementedException(
+ "isRpcThrottleEnabled by pattern not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean exceedThrottleQuotaSwitch(boolean enable) throws IOException {
+ throw new NotImplementedException(
+ "exceedThrottleQuotaSwitch by pattern not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<TableDescriptor> listTableDescriptors(List<TableName> tableNames) throws IOException {
+ throw new NotImplementedException("listTableDescriptors not supported in ThriftAdmin"
+ + ", use getDescriptor to get descriptors one by one");
+ }
+
+ @Override
+ public List<RegionInfo> getRegions(ServerName serverName) {
+ throw new NotImplementedException("getRegions not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void flush(TableName tableName) {
+ throw new NotImplementedException("flush not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void flush(TableName tableName, byte[] columnFamily) {
+ throw new NotImplementedException("flush not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void flushRegion(byte[] regionName) {
+ throw new NotImplementedException("flushRegion not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void flushRegion(byte[] regionName, byte[] columnFamily) {
+ throw new NotImplementedException("flushRegion not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void flushRegionServer(ServerName serverName) {
+ throw new NotImplementedException("flushRegionServer not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void compact(TableName tableName) {
+ throw new NotImplementedException("compact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void compactRegion(byte[] regionName) {
+ throw new NotImplementedException("compactRegion not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void compact(TableName tableName, byte[] columnFamily) {
+ throw new NotImplementedException("compact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void compactRegion(byte[] regionName, byte[] columnFamily) {
+ throw new NotImplementedException("compactRegion not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void compact(TableName tableName, CompactType compactType) {
+ throw new NotImplementedException("compact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void compact(TableName tableName, byte[] columnFamily, CompactType compactType) {
+ throw new NotImplementedException("compact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void majorCompact(TableName tableName) {
+ throw new NotImplementedException("majorCompact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void majorCompactRegion(byte[] regionName) {
+ throw new NotImplementedException("majorCompactRegion not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void majorCompact(TableName tableName, byte[] columnFamily) {
+ throw new NotImplementedException("majorCompact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void majorCompactRegion(byte[] regionName, byte[] columnFamily) {
+ throw new NotImplementedException("majorCompactRegion not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void majorCompact(TableName tableName, CompactType compactType) {
+ throw new NotImplementedException("majorCompact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void majorCompact(TableName tableName, byte[] columnFamily, CompactType compactType) {
+ throw new NotImplementedException("majorCompact not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public Map<ServerName, Boolean> compactionSwitch(boolean switchState,
+ List<String> serverNamesList) {
+ throw new NotImplementedException("compactionSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void compactRegionServer(ServerName serverName) {
+ throw new NotImplementedException("compactRegionServer not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void majorCompactRegionServer(ServerName serverName) {
+ throw new NotImplementedException("majorCompactRegionServer not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void move(byte[] encodedRegionName) {
+ throw new NotImplementedException("move not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void move(byte[] encodedRegionName, ServerName destServerName) {
+ throw new NotImplementedException("move not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void assign(byte[] regionName) {
+ throw new NotImplementedException("assign not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void unassign(byte[] regionName) {
+ throw new NotImplementedException("unassign not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void offline(byte[] regionName) {
+ throw new NotImplementedException("offline not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public boolean balancerSwitch(boolean onOrOff, boolean synchronous) {
+ throw new NotImplementedException("balancerSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean balance() {
+ throw new NotImplementedException("balance not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean balance(boolean force) {
+ throw new NotImplementedException("balance not supported in ThriftAdmin");
+ }
+
+ @Override
+ public BalanceResponse balance(BalanceRequest request) throws IOException {
+ throw new NotImplementedException("balance not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isBalancerEnabled() {
+ throw new NotImplementedException("isBalancerEnabled not supported in ThriftAdmin");
+ }
+
+ @Override
+ public CacheEvictionStats clearBlockCache(TableName tableName) {
+ throw new NotImplementedException("clearBlockCache not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean normalize(NormalizeTableFilterParams ntfp) {
+ throw new NotImplementedException("normalize not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isNormalizerEnabled() {
+ throw new NotImplementedException("isNormalizerEnabled not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean normalizerSwitch(boolean on) {
+ throw new NotImplementedException("normalizerSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean catalogJanitorSwitch(boolean onOrOff) {
+ throw new NotImplementedException("catalogJanitorSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public int runCatalogJanitor() {
+ throw new NotImplementedException("runCatalogJanitor not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isCatalogJanitorEnabled() {
+ throw new NotImplementedException("isCatalogJanitorEnabled not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean cleanerChoreSwitch(boolean onOrOff) {
+ throw new NotImplementedException("cleanerChoreSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean runCleanerChore() {
+ throw new NotImplementedException("runCleanerChore not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isCleanerChoreEnabled() {
+ throw new NotImplementedException("isCleanerChoreEnabled not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> mergeRegionsAsync(byte[] nameOfRegionA, byte[] nameOfRegionB,
+ boolean forcible) {
+ throw new NotImplementedException("mergeRegionsAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> mergeRegionsAsync(byte[][] nameofRegionsToMerge, boolean forcible) {
+ throw new NotImplementedException("mergeRegionsAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void split(TableName tableName) {
+ throw new NotImplementedException("split not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void split(TableName tableName, byte[] splitPoint) {
+ throw new NotImplementedException("split not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> splitRegionAsync(byte[] regionName, byte[] splitPoint) {
+ throw new NotImplementedException("splitRegionAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> modifyTableAsync(TableDescriptor td) {
+ throw new NotImplementedException("modifyTableAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void shutdown() {
+ throw new NotImplementedException("shutdown not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void stopMaster() {
+ throw new NotImplementedException("stopMaster not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public boolean isMasterInMaintenanceMode() {
+ throw new NotImplementedException("isMasterInMaintenanceMode not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void stopRegionServer(String hostnamePort) {
+ throw new NotImplementedException("stopRegionServer not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public ClusterMetrics getClusterMetrics(EnumSet<ClusterMetrics.Option> options) {
+ throw new NotImplementedException("getClusterMetrics not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<RegionMetrics> getRegionMetrics(ServerName serverName) {
+ throw new NotImplementedException("getRegionMetrics not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<RegionMetrics> getRegionMetrics(ServerName serverName, TableName tableName) {
+ throw new NotImplementedException("getRegionMetrics not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> createNamespaceAsync(NamespaceDescriptor descriptor) {
+ throw new NotImplementedException("createNamespaceAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> modifyNamespaceAsync(NamespaceDescriptor descriptor) {
+ throw new NotImplementedException("modifyNamespaceAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<RegionInfo> getRegions(TableName tableName) {
+ throw new NotImplementedException("getRegions not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean abortProcedure(long procId, boolean mayInterruptIfRunning) {
+ throw new NotImplementedException("abortProcedure not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Boolean> abortProcedureAsync(long procId, boolean mayInterruptIfRunning) {
+ throw new NotImplementedException("abortProcedureAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public String getProcedures() {
+ throw new NotImplementedException("getProcedures not supported in ThriftAdmin");
+ }
+
+ @Override
+ public String getLocks() {
+ throw new NotImplementedException("getLocks not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void rollWALWriter(ServerName serverName) {
+ throw new NotImplementedException("rollWALWriter not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public CompactionState getCompactionState(TableName tableName) {
+ throw new NotImplementedException("getCompactionState not supported in ThriftAdmin");
+ }
+
+ @Override
+ public CompactionState getCompactionState(TableName tableName, CompactType compactType) {
+ throw new NotImplementedException("getCompactionState not supported in ThriftAdmin");
+ }
+
+ @Override
+ public CompactionState getCompactionStateForRegion(byte[] regionName) {
+ throw new NotImplementedException("getCompactionStateForRegion not supported in ThriftAdmin");
+ }
+
+ @Override
+ public long getLastMajorCompactionTimestamp(TableName tableName) {
+ throw new NotImplementedException(
+ "getLastMajorCompactionTimestamp not supported in ThriftAdmin");
+ }
+
+ @Override
+ public long getLastMajorCompactionTimestampForRegion(byte[] regionName) {
+ throw new NotImplementedException(
+ "getLastMajorCompactionTimestampForRegion not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void snapshot(String snapshotName, TableName tableName) {
+ throw new NotImplementedException("snapshot not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void snapshot(String snapshotName, TableName tableName, SnapshotType type) {
+ throw new NotImplementedException("snapshot not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void snapshot(SnapshotDescription snapshot) {
+ throw new NotImplementedException("snapshot not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public Future<Void> snapshotAsync(SnapshotDescription snapshot) {
+ throw new NotImplementedException("snapshotAsync not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public boolean isSnapshotFinished(SnapshotDescription snapshot) {
+ throw new NotImplementedException("isSnapshotFinished not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void restoreSnapshot(String snapshotName) {
+ throw new NotImplementedException("restoreSnapshot not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot,
+ boolean restoreAcl) {
+ throw new NotImplementedException("restoreSnapshot not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> cloneSnapshotAsync(String snapshotName, TableName tableName, boolean cloneAcl,
+ String customSFT) throws IOException, TableExistsException, RestoreSnapshotException {
+ throw new NotImplementedException("cloneSnapshotAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void execProcedure(String signature, String instance, Map<String, String> props) {
+ throw new NotImplementedException("execProcedure not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public byte[] execProcedureWithReturn(String signature, String instance,
+ Map<String, String> props) {
+ throw new NotImplementedException("execProcedureWithReturn not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isProcedureFinished(String signature, String instance, Map<String, String> props) {
+ throw new NotImplementedException("isProcedureFinished not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<SnapshotDescription> listSnapshots() {
+ throw new NotImplementedException("listSnapshots not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<SnapshotDescription> listSnapshots(Pattern pattern) {
+ throw new NotImplementedException("listSnapshots not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<SnapshotDescription> listTableSnapshots(Pattern tableNamePattern,
+ Pattern snapshotNamePattern) {
+ throw new NotImplementedException("listTableSnapshots not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void deleteSnapshot(String snapshotName) {
+ throw new NotImplementedException("deleteSnapshot not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void deleteSnapshots(Pattern pattern) {
+ throw new NotImplementedException("deleteSnapshots not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void deleteTableSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern) {
+ throw new NotImplementedException("deleteTableSnapshots not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void setQuota(QuotaSettings quota) {
+ throw new NotImplementedException("setQuota not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<QuotaSettings> getQuota(QuotaFilter filter) {
+ throw new NotImplementedException("getQuota not supported in ThriftAdmin");
+ }
+
+ @Override
+ public CoprocessorRpcChannel coprocessorService() {
+ throw new NotImplementedException("coprocessorService not supported in ThriftAdmin");
+ }
+
+ @Override
+ public CoprocessorRpcChannel coprocessorService(ServerName serverName) {
+ throw new NotImplementedException("coprocessorService not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void updateConfiguration(ServerName server) {
+ throw new NotImplementedException("updateConfiguration not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void updateConfiguration() {
+ throw new NotImplementedException("updateConfiguration not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void updateConfiguration(String groupName) {
+ throw new NotImplementedException("updateConfiguration not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<SecurityCapability> getSecurityCapabilities() {
+ throw new NotImplementedException("getSecurityCapabilities not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean splitSwitch(boolean enabled, boolean synchronous) {
+ throw new NotImplementedException("splitSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean mergeSwitch(boolean enabled, boolean synchronous) {
+ throw new NotImplementedException("mergeSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isSplitEnabled() {
+ throw new NotImplementedException("isSplitEnabled not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isMergeEnabled() {
+ throw new NotImplementedException("isMergeEnabled not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> addReplicationPeerAsync(String peerId, ReplicationPeerConfig peerConfig,
+ boolean enabled) {
+ throw new NotImplementedException("addReplicationPeerAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> removeReplicationPeerAsync(String peerId) {
+ throw new NotImplementedException("removeReplicationPeerAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> enableReplicationPeerAsync(String peerId) {
+ throw new NotImplementedException("enableReplicationPeerAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> disableReplicationPeerAsync(String peerId) {
+ throw new NotImplementedException("disableReplicationPeerAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public ReplicationPeerConfig getReplicationPeerConfig(String peerId) {
+ throw new NotImplementedException("getReplicationPeerConfig not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> updateReplicationPeerConfigAsync(String peerId,
+ ReplicationPeerConfig peerConfig) {
+ throw new NotImplementedException(
+ "updateReplicationPeerConfigAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<ReplicationPeerDescription> listReplicationPeers() {
+ throw new NotImplementedException("listReplicationPeers not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<ReplicationPeerDescription> listReplicationPeers(Pattern pattern) {
+ throw new NotImplementedException("listReplicationPeers not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> transitReplicationPeerSyncReplicationStateAsync(String peerId,
+ SyncReplicationState state) {
+ throw new NotImplementedException(
+ "transitReplicationPeerSyncReplicationStateAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void decommissionRegionServers(List<ServerName> servers, boolean offload) {
+ throw new NotImplementedException("decommissionRegionServers not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public List<ServerName> listDecommissionedRegionServers() {
+ throw new NotImplementedException(
+ "listDecommissionedRegionServers not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void recommissionRegionServer(ServerName server, List<byte[]> encodedRegionNames) {
+ throw new NotImplementedException("recommissionRegionServer not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public List<TableCFs> listReplicatedTableCFs() {
+ throw new NotImplementedException("listReplicatedTableCFs not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void enableTableReplication(TableName tableName) {
+ throw new NotImplementedException("enableTableReplication not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void disableTableReplication(TableName tableName) {
+ throw new NotImplementedException("disableTableReplication not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public void clearCompactionQueues(ServerName serverName, Set<String> queues) {
+ throw new NotImplementedException("clearCompactionQueues not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public List<ServerName> clearDeadServers(List<ServerName> servers) {
+ throw new NotImplementedException("clearDeadServers not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void cloneTableSchema(TableName tableName, TableName newTableName,
+ boolean preserveSplits) {
+ throw new NotImplementedException("cloneTableSchema not supported in ThriftAdmin");
+
+ }
+
+ @Override
+ public Future<Void> createTableAsync(TableDescriptor desc) {
+ throw new NotImplementedException("createTableAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> createTableAsync(TableDescriptor desc, byte[][] splitKeys) {
+ throw new NotImplementedException("createTableAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> deleteTableAsync(TableName tableName) {
+ throw new NotImplementedException("deleteTableAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> truncateTableAsync(TableName tableName, boolean preserveSplits) {
+ throw new NotImplementedException("truncateTableAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> enableTableAsync(TableName tableName) {
+ throw new NotImplementedException("enableTableAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> disableTableAsync(TableName tableName) {
+ throw new NotImplementedException("disableTableAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> deleteColumnFamilyAsync(TableName tableName, byte[] columnFamily) {
+ throw new NotImplementedException("deleteColumnFamilyAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> addColumnFamilyAsync(TableName tableName,
+ ColumnFamilyDescriptor columnFamily) {
+ throw new NotImplementedException("addColumnFamilyAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> modifyColumnFamilyAsync(TableName tableName,
+ ColumnFamilyDescriptor columnFamily) {
+ throw new NotImplementedException("modifyColumnFamilyAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> deleteNamespaceAsync(String name) {
+ throw new NotImplementedException("deleteNamespaceAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Map<TableName, Long> getSpaceQuotaTableSizes() throws IOException {
+ throw new NotImplementedException("getSpaceQuotaTableSizes not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Map<TableName, SpaceQuotaSnapshot>
+ getRegionServerSpaceQuotaSnapshots(ServerName serverName) throws IOException {
+ throw new NotImplementedException(
+ "getRegionServerSpaceQuotaSnapshots not supported in ThriftAdmin");
+ }
+
+ @Override
+ public SpaceQuotaSnapshot getCurrentSpaceQuotaSnapshot(String namespace) throws IOException {
+ throw new NotImplementedException("getCurrentSpaceQuotaSnapshot not supported in ThriftAdmin");
+ }
+
+ @Override
+ public SpaceQuotaSnapshot getCurrentSpaceQuotaSnapshot(TableName tableName) throws IOException {
+ throw new NotImplementedException("getCurrentSpaceQuotaSnapshot not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void grant(UserPermission userPermission, boolean mergeExistingPermissions) {
+ throw new NotImplementedException("grant not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void revoke(UserPermission userPermission) {
+ throw new NotImplementedException("revoke not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<UserPermission>
+ getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest) {
+ throw new NotImplementedException("getUserPermissions not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<Boolean> hasUserPermissions(String userName, List<Permission> permissions) {
+ throw new NotImplementedException("hasUserPermissions not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean snapshotCleanupSwitch(boolean on, boolean synchronous) {
+ throw new NotImplementedException("snapshotCleanupSwitch not supported in ThriftAdmin");
+ }
+
+ @Override
+ public boolean isSnapshotCleanupEnabled() {
+ throw new NotImplementedException("isSnapshotCleanupEnabled not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<OnlineLogRecord> getSlowLogResponses(final Set<ServerName> serverNames,
+ final LogQueryFilter logQueryFilter) throws IOException {
+ Set<TServerName> tServerNames = ThriftUtilities.getServerNamesFromHBase(serverNames);
+ TLogQueryFilter tLogQueryFilter = ThriftUtilities.getSlowLogQueryFromHBase(logQueryFilter);
+ try {
+ List<TOnlineLogRecord> tOnlineLogRecords =
+ client.getSlowLogResponses(tServerNames, tLogQueryFilter);
+ return ThriftUtilities.getSlowLogRecordsFromThrift(tOnlineLogRecords);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public List<Boolean> clearSlowLogResponses(final Set<ServerName> serverNames) throws IOException {
+ Set<TServerName> tServerNames = ThriftUtilities.getServerNamesFromHBase(serverNames);
+ try {
+ return client.clearSlowLogResponses(tServerNames);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public RSGroupInfo getRSGroup(String groupName) {
+ throw new NotImplementedException("getRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void moveServersToRSGroup(Set<Address> servers, String targetGroup) {
+ throw new NotImplementedException("moveToRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void addRSGroup(String groupName) {
+ throw new NotImplementedException("addRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void removeRSGroup(String groupName) {
+ throw new NotImplementedException("removeRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public BalanceResponse balanceRSGroup(String groupName, BalanceRequest request) {
+ throw new NotImplementedException("balanceRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<RSGroupInfo> listRSGroups() {
+ throw new NotImplementedException("listRSGroups not supported in ThriftAdmin");
+ }
+
+ @Override
+ public RSGroupInfo getRSGroup(Address hostPort) {
+ throw new NotImplementedException("getRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void removeServersFromRSGroup(Set<Address> servers) {
+ throw new NotImplementedException("removeRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public RSGroupInfo getRSGroup(TableName tableName) {
+ throw new NotImplementedException("getRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void setRSGroup(Set<TableName> tables, String groupName) {
+ throw new NotImplementedException("setRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> splitRegionAsync(byte[] regionName) throws IOException {
+ return splitRegionAsync(regionName, null);
+ }
+
+ @Override
+ public List<TableName> listTablesInRSGroup(String groupName) throws IOException {
+ throw new NotImplementedException("setRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Pair<List<String>, List<TableName>>
+ getConfiguredNamespacesAndTablesInRSGroup(String groupName) throws IOException {
+ throw new NotImplementedException("setRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void renameRSGroup(String oldName, String newName) throws IOException {
+ throw new NotImplementedException("renameRSGroup not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void updateRSGroupConfig(String groupName, Map<String, String> configuration)
+ throws IOException {
+ throw new NotImplementedException("updateRSGroupConfig not supported in ThriftAdmin");
+ }
+
+ @Override
+ public List<LogEntry> getLogEntries(Set<ServerName> serverNames, String logType,
+ ServerType serverType, int limit, Map<String, Object> filterParams) throws IOException {
+ throw new NotImplementedException("getLogEntries not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> modifyColumnFamilyStoreFileTrackerAsync(TableName tableName, byte[] family,
+ String dstSFT) throws IOException {
+ throw new NotImplementedException(
+ "modifyColumnFamilyStoreFileTrackerAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public Future<Void> modifyTableStoreFileTrackerAsync(TableName tableName, String dstSFT)
+ throws IOException {
+ throw new NotImplementedException(
+ "modifyTableStoreFileTrackerAsync not supported in ThriftAdmin");
+ }
+
+ @Override
+ public void flushMasterStore() throws IOException {
+ throw new NotImplementedException("flushMasterStore not supported in ThriftAdmin");
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftClientBuilder.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftClientBuilder.java
new file mode 100644
index 0000000..c7d4d77
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftClientBuilder.java
@@ -0,0 +1,35 @@
+/*
+ * 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.thrift2.client;
+
+import java.io.IOException;
+import org.apache.hadoop.hbase.thrift2.generated.THBaseService;
+import org.apache.hadoop.hbase.util.Pair;
+import org.apache.thrift.transport.TTransport;
+import org.apache.yetus.audience.InterfaceAudience;
+
+@InterfaceAudience.Private
+public abstract class ThriftClientBuilder {
+ protected ThriftConnection connection;
+
+ public ThriftClientBuilder(ThriftConnection connection) {
+ this.connection = connection;
+ }
+
+ public abstract Pair<THBaseService.Client, TTransport> getClient() throws IOException;
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftConnection.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftConnection.java
new file mode 100644
index 0000000..250b8a7
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftConnection.java
@@ -0,0 +1,382 @@
+/*
+ * 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.thrift2.client;
+
+import static org.apache.hadoop.hbase.ipc.RpcClient.DEFAULT_SOCKET_TIMEOUT_CONNECT;
+import static org.apache.hadoop.hbase.ipc.RpcClient.SOCKET_TIMEOUT_CONNECT;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.lang.reflect.Constructor;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import javax.net.ssl.SSLException;
+import org.apache.commons.lang3.NotImplementedException;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.Admin;
+import org.apache.hadoop.hbase.client.AsyncConnection;
+import org.apache.hadoop.hbase.client.BufferedMutator;
+import org.apache.hadoop.hbase.client.BufferedMutatorParams;
+import org.apache.hadoop.hbase.client.Connection;
+import org.apache.hadoop.hbase.client.ConnectionUtils;
+import org.apache.hadoop.hbase.client.RegionLocator;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.client.TableBuilder;
+import org.apache.hadoop.hbase.security.User;
+import org.apache.hadoop.hbase.thrift.Constants;
+import org.apache.hadoop.hbase.thrift2.generated.THBaseService;
+import org.apache.hadoop.hbase.util.Pair;
+import org.apache.http.HttpRequest;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.utils.HttpClientUtils;
+import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.protocol.HttpContext;
+import org.apache.thrift.TException;
+import org.apache.thrift.protocol.TBinaryProtocol;
+import org.apache.thrift.protocol.TCompactProtocol;
+import org.apache.thrift.protocol.TProtocol;
+import org.apache.thrift.transport.THttpClient;
+import org.apache.thrift.transport.TSocket;
+import org.apache.thrift.transport.TTransport;
+import org.apache.thrift.transport.TTransportException;
+import org.apache.thrift.transport.layered.TFramedTransport;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.hbase.thirdparty.com.google.common.base.Preconditions;
+
+@InterfaceAudience.Private
+public class ThriftConnection implements Connection {
+ private static final Logger LOG = LoggerFactory.getLogger(ThriftConnection.class);
+ private Configuration conf;
+ private User user;
+ // For HTTP protocol
+ private HttpClient httpClient;
+ private boolean httpClientCreated = false;
+ private boolean isClosed = false;
+
+ private String host;
+ private int port;
+ private boolean isFramed = false;
+ private boolean isCompact = false;
+
+ // TODO: We can rip out the ThriftClient piece of it rather than creating a new client every time.
+ ThriftClientBuilder clientBuilder;
+
+ private int operationTimeout;
+ private int connectTimeout;
+
+ public ThriftConnection(Configuration conf, ExecutorService pool, final User user)
+ throws IOException {
+ this.conf = conf;
+ this.user = user;
+ this.host = conf.get(Constants.HBASE_THRIFT_SERVER_NAME);
+ this.port = conf.getInt(Constants.HBASE_THRIFT_SERVER_PORT, -1);
+ Preconditions.checkArgument(port > 0);
+ Preconditions.checkArgument(host != null);
+ this.isFramed = conf.getBoolean(Constants.FRAMED_CONF_KEY, Constants.FRAMED_CONF_DEFAULT);
+ this.isCompact = conf.getBoolean(Constants.COMPACT_CONF_KEY, Constants.COMPACT_CONF_DEFAULT);
+ this.operationTimeout = conf.getInt(HConstants.HBASE_CLIENT_OPERATION_TIMEOUT,
+ HConstants.DEFAULT_HBASE_CLIENT_OPERATION_TIMEOUT);
+ this.connectTimeout = conf.getInt(SOCKET_TIMEOUT_CONNECT, DEFAULT_SOCKET_TIMEOUT_CONNECT);
+
+ String className = conf.get(Constants.HBASE_THRIFT_CLIENT_BUIDLER_CLASS,
+ DefaultThriftClientBuilder.class.getName());
+ try {
+ Class<?> clazz = Class.forName(className);
+ Constructor<?> constructor = clazz.getDeclaredConstructor(ThriftConnection.class);
+ constructor.setAccessible(true);
+ clientBuilder = (ThriftClientBuilder) constructor.newInstance(this);
+ } catch (Exception e) {
+ throw new IOException(e);
+ }
+ }
+
+ public synchronized void setHttpClient(HttpClient httpClient) {
+ this.httpClient = httpClient;
+ }
+
+ @Override
+ public Configuration getConfiguration() {
+ return conf;
+ }
+
+ public String getHost() {
+ return host;
+ }
+
+ public int getPort() {
+ return port;
+ }
+
+ public boolean isFramed() {
+ return isFramed;
+ }
+
+ public boolean isCompact() {
+ return isCompact;
+ }
+
+ public int getOperationTimeout() {
+ return operationTimeout;
+ }
+
+ public int getConnectTimeout() {
+ return connectTimeout;
+ }
+
+ /**
+ * the default thrift client builder. One can extend the ThriftClientBuilder to builder custom
+ * client, implement features like authentication(hbase-examples/thrift/DemoClient)
+ */
+ public static class DefaultThriftClientBuilder extends ThriftClientBuilder {
+
+ @Override
+ public Pair<THBaseService.Client, TTransport> getClient() throws IOException {
+ TTransport tTransport = null;
+ try {
+ TSocket sock = new TSocket(connection.getHost(), connection.getPort());
+ sock.setSocketTimeout(connection.getOperationTimeout());
+ sock.setConnectTimeout(connection.getConnectTimeout());
+ tTransport = sock;
+ if (connection.isFramed()) {
+ tTransport = new TFramedTransport(tTransport);
+ }
+
+ sock.open();
+ } catch (TTransportException e) {
+ throw new IOException(e);
+ }
+ TProtocol prot;
+ if (connection.isCompact()) {
+ prot = new TCompactProtocol(tTransport);
+ } else {
+ prot = new TBinaryProtocol(tTransport);
+ }
+ THBaseService.Client client = new THBaseService.Client(prot);
+ return new Pair<>(client, tTransport);
+ }
+
+ public DefaultThriftClientBuilder(ThriftConnection connection) {
+ super(connection);
+ }
+ }
+
+ /**
+ * the default thrift http client builder. One can extend the ThriftClientBuilder to builder
+ * custom http client, implement features like authentication or
+ * 'DoAs'(hbase-examples/thrift/HttpDoAsClient)
+ */
+ public static class HTTPThriftClientBuilder extends ThriftClientBuilder {
+ Map<String, String> customHeader = new HashMap<>();
+
+ public HTTPThriftClientBuilder(ThriftConnection connection) {
+ super(connection);
+ }
+
+ public void addCostumHeader(String key, String value) {
+ customHeader.put(key, value);
+ }
+
+ @Override
+ public Pair<THBaseService.Client, TTransport> getClient() throws IOException {
+ Preconditions.checkArgument(connection.getHost().startsWith("http"),
+ "http client host must start with http or https");
+ String url = connection.getHost() + ":" + connection.getPort();
+ try {
+ THttpClient httpClient = new THttpClient(url, connection.getHttpClient());
+ for (Map.Entry<String, String> header : customHeader.entrySet()) {
+ httpClient.setCustomHeader(header.getKey(), header.getValue());
+ }
+ httpClient.open();
+ TProtocol prot = new TBinaryProtocol(httpClient);
+ THBaseService.Client client = new THBaseService.Client(prot);
+ return new Pair<>(client, httpClient);
+ } catch (TTransportException e) {
+ throw new IOException(e);
+ }
+
+ }
+ }
+
+ /**
+ * Get a ThriftAdmin, ThriftAdmin is NOT thread safe
+ * @return a ThriftAdmin
+ * @throws IOException IOException
+ */
+ @Override
+ public Admin getAdmin() throws IOException {
+ Pair<THBaseService.Client, TTransport> client = clientBuilder.getClient();
+ return new ThriftAdmin(client.getFirst(), client.getSecond(), conf);
+ }
+
+ public static class DelayRetryHandler extends DefaultHttpRequestRetryHandler {
+ private long pause;
+
+ public DelayRetryHandler(int retryCount, long pause) {
+ super(retryCount, true, Arrays.asList(InterruptedIOException.class,
+ UnknownHostException.class, SSLException.class));
+ this.pause = pause;
+ }
+
+ @Override
+ public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
+ // Don't sleep for retrying the first time
+ if (executionCount > 1 && pause > 0) {
+ try {
+ long sleepTime = ConnectionUtils.getPauseTime(pause, executionCount - 1);
+ Thread.sleep(sleepTime);
+ } catch (InterruptedException ie) {
+ // reset interrupt marker
+ Thread.currentThread().interrupt();
+ }
+ }
+ return super.retryRequest(exception, executionCount, context);
+ }
+
+ @Override
+ protected boolean handleAsIdempotent(HttpRequest request) {
+ return true;
+ }
+ }
+
+ public synchronized HttpClient getHttpClient() {
+ if (httpClient != null) {
+ return httpClient;
+ }
+ int retry = conf.getInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,
+ HConstants.DEFAULT_HBASE_CLIENT_RETRIES_NUMBER);
+ long pause = conf.getLong(HConstants.HBASE_CLIENT_PAUSE, 5);
+ HttpClientBuilder builder = HttpClientBuilder.create();
+ RequestConfig.Builder requestBuilder = RequestConfig.custom();
+ requestBuilder = requestBuilder.setConnectTimeout(getConnectTimeout());
+ requestBuilder = requestBuilder.setSocketTimeout(getOperationTimeout());
+ builder.setRetryHandler(new DelayRetryHandler(retry, pause));
+ builder.setDefaultRequestConfig(requestBuilder.build());
+ httpClient = builder.build();
+ httpClientCreated = true;
+ return httpClient;
+ }
+
+ @Override
+ public synchronized void close() throws IOException {
+ if (httpClient != null && httpClientCreated) {
+ HttpClientUtils.closeQuietly(httpClient);
+ }
+ isClosed = true;
+ }
+
+ @Override
+ public boolean isClosed() {
+ return isClosed;
+ }
+
+ /**
+ * Get a TableBuider to build ThriftTable, ThriftTable is NOT thread safe
+ * @return a TableBuilder
+ * @throws IOException IOException
+ */
+ @Override
+ public TableBuilder getTableBuilder(TableName tableName, ExecutorService pool) {
+ return new TableBuilder() {
+ @Override
+ public TableBuilder setOperationTimeout(int timeout) {
+ return this;
+ }
+
+ @Override
+ public TableBuilder setRpcTimeout(int timeout) {
+ return this;
+ }
+
+ @Override
+ public TableBuilder setReadRpcTimeout(int timeout) {
+ return this;
+ }
+
+ @Override
+ public TableBuilder setWriteRpcTimeout(int timeout) {
+ return this;
+ }
+
+ @Override
+ public Table build() {
+ try {
+ Pair<THBaseService.Client, TTransport> client = clientBuilder.getClient();
+ return new ThriftTable(tableName, client.getFirst(), client.getSecond(), conf);
+ } catch (IOException ioE) {
+ throw new RuntimeException(ioE);
+ }
+ }
+ };
+ }
+
+ @Override
+ public void abort(String why, Throwable e) {
+
+ }
+
+ @Override
+ public boolean isAborted() {
+ return false;
+ }
+
+ @Override
+ public BufferedMutator getBufferedMutator(TableName tableName) throws IOException {
+ throw new NotImplementedException("batchCoprocessorService not supported in ThriftTable");
+ }
+
+ @Override
+ public BufferedMutator getBufferedMutator(BufferedMutatorParams params) throws IOException {
+ throw new NotImplementedException("batchCoprocessorService not supported in ThriftTable");
+ }
+
+ @Override
+ public RegionLocator getRegionLocator(TableName tableName) throws IOException {
+ throw new NotImplementedException("batchCoprocessorService not supported in ThriftTable");
+ }
+
+ @Override
+ public void clearRegionLocationCache() {
+ throw new NotImplementedException("clearRegionLocationCache not supported in ThriftTable");
+ }
+
+ @Override
+ public AsyncConnection toAsyncConnection() {
+ throw new NotImplementedException("toAsyncConnection not supported in ThriftTable");
+ }
+
+ @Override
+ public String getClusterId() {
+ try {
+ Pair<THBaseService.Client, TTransport> client = clientBuilder.getClient();
+ return client.getFirst().getClusterId();
+ } catch (TException | IOException e) {
+ LOG.error("Error fetching cluster ID: ", e);
+ }
+ return null;
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftTable.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftTable.java
new file mode 100644
index 0000000..d8f22f1
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftTable.java
@@ -0,0 +1,505 @@
+/*
+ * 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.thrift2.client;
+
+import static org.apache.hadoop.hbase.thrift.Constants.HBASE_THRIFT_CLIENT_SCANNER_CACHING;
+import static org.apache.hadoop.hbase.thrift.Constants.HBASE_THRIFT_CLIENT_SCANNER_CACHING_DEFAULT;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
+import org.apache.commons.lang3.NotImplementedException;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.CompareOperator;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.Append;
+import org.apache.hadoop.hbase.client.CheckAndMutate;
+import org.apache.hadoop.hbase.client.CheckAndMutateResult;
+import org.apache.hadoop.hbase.client.Delete;
+import org.apache.hadoop.hbase.client.Get;
+import org.apache.hadoop.hbase.client.Increment;
+import org.apache.hadoop.hbase.client.Put;
+import org.apache.hadoop.hbase.client.RegionLocator;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.client.ResultScanner;
+import org.apache.hadoop.hbase.client.Row;
+import org.apache.hadoop.hbase.client.RowMutations;
+import org.apache.hadoop.hbase.client.Scan;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.client.coprocessor.Batch;
+import org.apache.hadoop.hbase.client.metrics.ScanMetrics;
+import org.apache.hadoop.hbase.filter.Filter;
+import org.apache.hadoop.hbase.io.TimeRange;
+import org.apache.hadoop.hbase.ipc.CoprocessorRpcChannel;
+import org.apache.hadoop.hbase.thrift2.ThriftUtilities;
+import org.apache.hadoop.hbase.thrift2.generated.TAppend;
+import org.apache.hadoop.hbase.thrift2.generated.TDelete;
+import org.apache.hadoop.hbase.thrift2.generated.TGet;
+import org.apache.hadoop.hbase.thrift2.generated.THBaseService;
+import org.apache.hadoop.hbase.thrift2.generated.TIncrement;
+import org.apache.hadoop.hbase.thrift2.generated.TPut;
+import org.apache.hadoop.hbase.thrift2.generated.TResult;
+import org.apache.hadoop.hbase.thrift2.generated.TRowMutations;
+import org.apache.hadoop.hbase.thrift2.generated.TScan;
+import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.thrift.TException;
+import org.apache.thrift.transport.TTransport;
+import org.apache.yetus.audience.InterfaceAudience;
+
+import org.apache.hbase.thirdparty.com.google.common.base.Preconditions;
+import org.apache.hbase.thirdparty.com.google.common.primitives.Booleans;
+
+@InterfaceAudience.Private
+public class ThriftTable implements Table {
+
+ private TableName tableName;
+ private Configuration conf;
+ private TTransport tTransport;
+ private THBaseService.Client client;
+ private ByteBuffer tableNameInBytes;
+ private int operationTimeout;
+
+ private final int scannerCaching;
+
+ public ThriftTable(TableName tableName, THBaseService.Client client, TTransport tTransport,
+ Configuration conf) {
+ this.tableName = tableName;
+ this.tableNameInBytes = ByteBuffer.wrap(tableName.toBytes());
+ this.conf = conf;
+ this.tTransport = tTransport;
+ this.client = client;
+ this.scannerCaching =
+ conf.getInt(HBASE_THRIFT_CLIENT_SCANNER_CACHING, HBASE_THRIFT_CLIENT_SCANNER_CACHING_DEFAULT);
+ this.operationTimeout = conf.getInt(HConstants.HBASE_CLIENT_OPERATION_TIMEOUT,
+ HConstants.DEFAULT_HBASE_CLIENT_OPERATION_TIMEOUT);
+
+ }
+
+ @Override
+ public TableName getName() {
+ return tableName;
+ }
+
+ @Override
+ public Configuration getConfiguration() {
+ return conf;
+ }
+
+ @Override
+ public TableDescriptor getDescriptor() throws IOException {
+ try {
+ TTableDescriptor tableDescriptor =
+ client.getTableDescriptor(ThriftUtilities.tableNameFromHBase(tableName));
+ return ThriftUtilities.tableDescriptorFromThrift(tableDescriptor);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public boolean exists(Get get) throws IOException {
+ TGet tGet = ThriftUtilities.getFromHBase(get);
+ try {
+ return client.exists(tableNameInBytes, tGet);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public boolean[] exists(List<Get> gets) throws IOException {
+ List<TGet> tGets = new ArrayList<>();
+ for (Get get : gets) {
+ tGets.add(ThriftUtilities.getFromHBase(get));
+ }
+ try {
+ List<Boolean> results = client.existsAll(tableNameInBytes, tGets);
+ return Booleans.toArray(results);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void batch(List<? extends Row> actions, Object[] results) throws IOException {
+ throw new IOException("Batch not supported in ThriftTable, use put(List<Put> puts), "
+ + "get(List<Get> gets) or delete(List<Delete> deletes) respectively");
+
+ }
+
+ @Override
+ public <R> void batchCallback(List<? extends Row> actions, Object[] results,
+ Batch.Callback<R> callback) throws IOException {
+ throw new IOException("BatchCallback not supported in ThriftTable, use put(List<Put> puts), "
+ + "get(List<Get> gets) or delete(List<Delete> deletes) respectively");
+ }
+
+ @Override
+ public Result get(Get get) throws IOException {
+ TGet tGet = ThriftUtilities.getFromHBase(get);
+ try {
+ TResult tResult = client.get(tableNameInBytes, tGet);
+ return ThriftUtilities.resultFromThrift(tResult);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public Result[] get(List<Get> gets) throws IOException {
+ List<TGet> tGets = ThriftUtilities.getsFromHBase(gets);
+ try {
+ List<TResult> results = client.getMultiple(tableNameInBytes, tGets);
+ return ThriftUtilities.resultsFromThrift(results);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ /**
+ * A scanner to perform scan from thrift server getScannerResults is used in this scanner
+ */
+ private class Scanner implements ResultScanner {
+ protected TScan scan;
+ protected Result lastResult = null;
+ protected final Queue<Result> cache = new ArrayDeque<>();;
+
+ public Scanner(Scan scan) throws IOException {
+ if (scan.getBatch() > 0) {
+ throw new IOException("Batch is not supported in Scanner");
+ }
+ if (scan.getCaching() <= 0) {
+ scan.setCaching(scannerCaching);
+ } else if (scan.getCaching() == 1 && scan.isReversed()) {
+ // for reverse scan, we need to pass the last row to the next scanner
+ // we need caching number bigger than 1
+ scan.setCaching(scan.getCaching() + 1);
+ }
+ this.scan = ThriftUtilities.scanFromHBase(scan);
+ }
+
+ @Override
+ public Result next() throws IOException {
+ if (cache.size() == 0) {
+ setupNextScanner();
+ try {
+ List<TResult> tResults =
+ client.getScannerResults(tableNameInBytes, scan, scan.getCaching());
+ Result[] results = ThriftUtilities.resultsFromThrift(tResults);
+ boolean firstKey = true;
+ for (Result result : results) {
+ // If it is a reverse scan, we use the last result's key as the startkey, since there is
+ // no way to construct a closet rowkey smaller than the last result
+ // So when the results return, we must rule out the first result, since it has already
+ // returned to user.
+ if (firstKey) {
+ firstKey = false;
+ if (scan.isReversed() && lastResult != null) {
+ if (Bytes.equals(lastResult.getRow(), result.getRow())) {
+ continue;
+ }
+ }
+ }
+ cache.add(result);
+ lastResult = result;
+ }
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ if (cache.size() > 0) {
+ return cache.poll();
+ } else {
+ // scan finished
+ return null;
+ }
+ }
+
+ @Override
+ public void close() {
+ }
+
+ @Override
+ public boolean renewLease() {
+ throw new RuntimeException("renewLease() not supported");
+ }
+
+ @Override
+ public ScanMetrics getScanMetrics() {
+ throw new RuntimeException("getScanMetrics() not supported");
+ }
+
+ private void setupNextScanner() {
+ // if lastResult is null null, it means it is not the fist scan
+ if (lastResult != null) {
+ byte[] lastRow = lastResult.getRow();
+ if (scan.isReversed()) {
+ // for reverse scan, we can't find the closet row before this row
+ scan.setStartRow(lastRow);
+ } else {
+ scan.setStartRow(createClosestRowAfter(lastRow));
+ }
+ }
+ }
+
+ /**
+ * Create the closest row after the specified row
+ */
+ protected byte[] createClosestRowAfter(byte[] row) {
+ if (row == null) {
+ throw new RuntimeException("The passed row is null");
+ }
+ return Arrays.copyOf(row, row.length + 1);
+ }
+ }
+
+ @Override
+ public ResultScanner getScanner(Scan scan) throws IOException {
+ return new Scanner(scan);
+ }
+
+ @Override
+ public ResultScanner getScanner(byte[] family) throws IOException {
+ Scan scan = new Scan();
+ scan.addFamily(family);
+ return getScanner(scan);
+ }
+
+ @Override
+ public ResultScanner getScanner(byte[] family, byte[] qualifier) throws IOException {
+ Scan scan = new Scan();
+ scan.addColumn(family, qualifier);
+ return getScanner(scan);
+ }
+
+ @Override
+ public void put(Put put) throws IOException {
+ TPut tPut = ThriftUtilities.putFromHBase(put);
+ try {
+ client.put(tableNameInBytes, tPut);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void put(List<Put> puts) throws IOException {
+ List<TPut> tPuts = ThriftUtilities.putsFromHBase(puts);
+ try {
+ client.putMultiple(tableNameInBytes, tPuts);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void delete(Delete delete) throws IOException {
+ TDelete tDelete = ThriftUtilities.deleteFromHBase(delete);
+ try {
+ client.deleteSingle(tableNameInBytes, tDelete);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void delete(List<Delete> deletes) throws IOException {
+ List<TDelete> tDeletes = ThriftUtilities.deletesFromHBase(deletes);
+ try {
+ client.deleteMultiple(tableNameInBytes, tDeletes);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ private class CheckAndMutateBuilderImpl implements CheckAndMutateBuilder {
+
+ private final byte[] row;
+ private final byte[] family;
+ private byte[] qualifier;
+ private CompareOperator op;
+ private byte[] value;
+
+ CheckAndMutateBuilderImpl(byte[] row, byte[] family) {
+ this.row = Preconditions.checkNotNull(row, "row is null");
+ this.family = Preconditions.checkNotNull(family, "family is null");
+ }
+
+ @Override
+ public CheckAndMutateBuilder qualifier(byte[] qualifier) {
+ this.qualifier = Preconditions.checkNotNull(qualifier, "qualifier is null. Consider using"
+ + " an empty byte array, or just do not call this method if you want a null qualifier");
+ return this;
+ }
+
+ @Override
+ public CheckAndMutateBuilder timeRange(TimeRange timeRange) {
+ throw new NotImplementedException("timeRange not supported in ThriftTable");
+ }
+
+ @Override
+ public CheckAndMutateBuilder ifNotExists() {
+ this.op = CompareOperator.EQUAL;
+ this.value = null;
+ return this;
+ }
+
+ @Override
+ public CheckAndMutateBuilder ifMatches(CompareOperator compareOp, byte[] value) {
+ this.op = Preconditions.checkNotNull(compareOp, "compareOp is null");
+ this.value = Preconditions.checkNotNull(value, "value is null");
+ return this;
+ }
+
+ private void preCheck() {
+ Preconditions.checkNotNull(op, "condition is null. You need to specify the condition by"
+ + " calling ifNotExists/ifEquals/ifMatches before executing the request");
+ }
+
+ @Override
+ public boolean thenPut(Put put) throws IOException {
+ preCheck();
+ RowMutations rowMutations = new RowMutations(put.getRow());
+ rowMutations.add(put);
+ return checkAndMutate(row, family, qualifier, op, value, rowMutations);
+ }
+
+ @Override
+ public boolean thenDelete(Delete delete) throws IOException {
+ preCheck();
+ RowMutations rowMutations = new RowMutations(delete.getRow());
+ rowMutations.add(delete);
+ return checkAndMutate(row, family, qualifier, op, value, rowMutations);
+ }
+
+ @Override
+ public boolean thenMutate(RowMutations mutation) throws IOException {
+ preCheck();
+ return checkAndMutate(row, family, qualifier, op, value, mutation);
+ }
+ }
+
+ private boolean checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op,
+ byte[] value, RowMutations mutation) throws IOException {
+ try {
+ ByteBuffer valueBuffer = value == null ? null : ByteBuffer.wrap(value);
+ return client.checkAndMutate(tableNameInBytes, ByteBuffer.wrap(row), ByteBuffer.wrap(family),
+ ByteBuffer.wrap(qualifier), ThriftUtilities.compareOpFromHBase(op), valueBuffer,
+ ThriftUtilities.rowMutationsFromHBase(mutation));
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public CheckAndMutateBuilder checkAndMutate(byte[] row, byte[] family) {
+ return new CheckAndMutateBuilderImpl(row, family);
+ }
+
+ @Override
+ public CheckAndMutateWithFilterBuilder checkAndMutate(byte[] row, Filter filter) {
+ throw new NotImplementedException("Implement later");
+ }
+
+ @Override
+ public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate) {
+ throw new NotImplementedException("Implement later");
+ }
+
+ @Override
+ public List<CheckAndMutateResult> checkAndMutate(List<CheckAndMutate> checkAndMutates) {
+ throw new NotImplementedException("Implement later");
+ }
+
+ @Override
+ public Result mutateRow(RowMutations rm) throws IOException {
+ TRowMutations tRowMutations = ThriftUtilities.rowMutationsFromHBase(rm);
+ try {
+ client.mutateRow(tableNameInBytes, tRowMutations);
+ return Result.EMPTY_RESULT;
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public Result append(Append append) throws IOException {
+ TAppend tAppend = ThriftUtilities.appendFromHBase(append);
+ try {
+ TResult tResult = client.append(tableNameInBytes, tAppend);
+ return ThriftUtilities.resultFromThrift(tResult);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public Result increment(Increment increment) throws IOException {
+ TIncrement tIncrement = ThriftUtilities.incrementFromHBase(increment);
+ try {
+ TResult tResult = client.increment(tableNameInBytes, tIncrement);
+ return ThriftUtilities.resultFromThrift(tResult);
+ } catch (TException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ public void close() throws IOException {
+ tTransport.close();
+ }
+
+ @Override
+ public long getRpcTimeout(TimeUnit unit) {
+ return unit.convert(operationTimeout, TimeUnit.MILLISECONDS);
+ }
+
+ @Override
+ public long getReadRpcTimeout(TimeUnit unit) {
+ return unit.convert(operationTimeout, TimeUnit.MILLISECONDS);
+ }
+
+ @Override
+ public long getWriteRpcTimeout(TimeUnit unit) {
+ return unit.convert(operationTimeout, TimeUnit.MILLISECONDS);
+ }
+
+ @Override
+ public long getOperationTimeout(TimeUnit unit) {
+ return unit.convert(operationTimeout, TimeUnit.MILLISECONDS);
+ }
+
+ @Override
+ public CoprocessorRpcChannel coprocessorService(byte[] row) {
+ throw new NotImplementedException("coprocessorService not supported in ThriftTable");
+ }
+
+ @Override
+ public RegionLocator getRegionLocator() throws IOException {
+ throw new NotImplementedException("getRegionLocator not supported in ThriftTable");
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/NamespaceDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/NamespaceDescriptor.java
new file mode 100644
index 0000000..3f9f512
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/NamespaceDescriptor.java
@@ -0,0 +1,554 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)", date = "2018-12-26")
+public class NamespaceDescriptor implements org.apache.thrift.TBase<NamespaceDescriptor, NamespaceDescriptor._Fields>, java.io.Serializable, Cloneable, Comparable<NamespaceDescriptor> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("NamespaceDescriptor");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField CONFIGURATION_FIELD_DESC = new org.apache.thrift.protocol.TField("configuration", org.apache.thrift.protocol.TType.MAP, (short)2);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new NamespaceDescriptorStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new NamespaceDescriptorTupleSchemeFactory());
+ }
+
+ public String name; // required
+ public Map<String,String> configuration; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ NAME((short)1, "name"),
+ CONFIGURATION((short)2, "configuration");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ case 2: // CONFIGURATION
+ return CONFIGURATION;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.CONFIGURATION};
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.CONFIGURATION, new org.apache.thrift.meta_data.FieldMetaData("configuration", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(NamespaceDescriptor.class, metaDataMap);
+ }
+
+ public NamespaceDescriptor() {
+ }
+
+ public NamespaceDescriptor(
+ String name)
+ {
+ this();
+ this.name = name;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public NamespaceDescriptor(NamespaceDescriptor other) {
+ if (other.isSetName()) {
+ this.name = other.name;
+ }
+ if (other.isSetConfiguration()) {
+ Map<String,String> __this__configuration = new HashMap<String,String>(other.configuration);
+ this.configuration = __this__configuration;
+ }
+ }
+
+ public NamespaceDescriptor deepCopy() {
+ return new NamespaceDescriptor(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ this.configuration = null;
+ }
+
+ public String getName() {
+ return this.name;
+ }
+
+ public NamespaceDescriptor setName(String name) {
+ this.name = name;
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public int getConfigurationSize() {
+ return (this.configuration == null) ? 0 : this.configuration.size();
+ }
+
+ public void putToConfiguration(String key, String val) {
+ if (this.configuration == null) {
+ this.configuration = new HashMap<String,String>();
+ }
+ this.configuration.put(key, val);
+ }
+
+ public Map<String,String> getConfiguration() {
+ return this.configuration;
+ }
+
+ public NamespaceDescriptor setConfiguration(Map<String,String> configuration) {
+ this.configuration = configuration;
+ return this;
+ }
+
+ public void unsetConfiguration() {
+ this.configuration = null;
+ }
+
+ /** Returns true if field configuration is set (has been assigned a value) and false otherwise */
+ public boolean isSetConfiguration() {
+ return this.configuration != null;
+ }
+
+ public void setConfigurationIsSet(boolean value) {
+ if (!value) {
+ this.configuration = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ setName((String)value);
+ }
+ break;
+
+ case CONFIGURATION:
+ if (value == null) {
+ unsetConfiguration();
+ } else {
+ setConfiguration((Map<String,String>)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ case CONFIGURATION:
+ return getConfiguration();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ case CONFIGURATION:
+ return isSetConfiguration();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof NamespaceDescriptor)
+ return this.equals((NamespaceDescriptor)that);
+ return false;
+ }
+
+ public boolean equals(NamespaceDescriptor that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ boolean this_present_configuration = true && this.isSetConfiguration();
+ boolean that_present_configuration = true && that.isSetConfiguration();
+ if (this_present_configuration || that_present_configuration) {
+ if (!(this_present_configuration && that_present_configuration))
+ return false;
+ if (!this.configuration.equals(that.configuration))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ List<Object> list = new ArrayList<Object>();
+
+ boolean present_name = true && (isSetName());
+ list.add(present_name);
+ if (present_name)
+ list.add(name);
+
+ boolean present_configuration = true && (isSetConfiguration());
+ list.add(present_configuration);
+ if (present_configuration)
+ list.add(configuration);
+
+ return list.hashCode();
+ }
+
+ @Override
+ public int compareTo(NamespaceDescriptor other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = Boolean.valueOf(isSetName()).compareTo(other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetConfiguration()).compareTo(other.isSetConfiguration());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetConfiguration()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.configuration, other.configuration);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("NamespaceDescriptor(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.name);
+ }
+ first = false;
+ if (isSetConfiguration()) {
+ if (!first) sb.append(", ");
+ sb.append("configuration:");
+ if (this.configuration == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.configuration);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (name == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class NamespaceDescriptorStandardSchemeFactory implements SchemeFactory {
+ public NamespaceDescriptorStandardScheme getScheme() {
+ return new NamespaceDescriptorStandardScheme();
+ }
+ }
+
+ private static class NamespaceDescriptorStandardScheme extends StandardScheme<NamespaceDescriptor> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, NamespaceDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // CONFIGURATION
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map180 = iprot.readMapBegin();
+ struct.configuration = new HashMap<String,String>(2*_map180.size);
+ String _key181;
+ String _val182;
+ for (int _i183 = 0; _i183 < _map180.size; ++_i183)
+ {
+ _key181 = iprot.readString();
+ _val182 = iprot.readString();
+ struct.configuration.put(_key181, _val182);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setConfigurationIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, NamespaceDescriptor struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeString(struct.name);
+ oprot.writeFieldEnd();
+ }
+ if (struct.configuration != null) {
+ if (struct.isSetConfiguration()) {
+ oprot.writeFieldBegin(CONFIGURATION_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.configuration.size()));
+ for (Map.Entry<String, String> _iter184 : struct.configuration.entrySet())
+ {
+ oprot.writeString(_iter184.getKey());
+ oprot.writeString(_iter184.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class NamespaceDescriptorTupleSchemeFactory implements SchemeFactory {
+ public NamespaceDescriptorTupleScheme getScheme() {
+ return new NamespaceDescriptorTupleScheme();
+ }
+ }
+
+ private static class NamespaceDescriptorTupleScheme extends TupleScheme<NamespaceDescriptor> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, NamespaceDescriptor struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ oprot.writeString(struct.name);
+ BitSet optionals = new BitSet();
+ if (struct.isSetConfiguration()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetConfiguration()) {
+ {
+ oprot.writeI32(struct.configuration.size());
+ for (Map.Entry<String, String> _iter185 : struct.configuration.entrySet())
+ {
+ oprot.writeString(_iter185.getKey());
+ oprot.writeString(_iter185.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, NamespaceDescriptor struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TMap _map186 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+ struct.configuration = new HashMap<String,String>(2*_map186.size);
+ String _key187;
+ String _val188;
+ for (int _i189 = 0; _i189 < _map186.size; ++_i189)
+ {
+ _key187 = iprot.readString();
+ _val188 = iprot.readString();
+ struct.configuration.put(_key187, _val188);
+ }
+ }
+ struct.setConfigurationIsSet(true);
+ }
+ }
+ }
+
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAccessControlEntity.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAccessControlEntity.java
new file mode 100644
index 0000000..b68d7ac
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAccessControlEntity.java
@@ -0,0 +1,807 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * TAccessControlEntity for permission control
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TAccessControlEntity implements org.apache.thrift.TBase<TAccessControlEntity, TAccessControlEntity._Fields>, java.io.Serializable, Cloneable, Comparable<TAccessControlEntity> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAccessControlEntity");
+
+ private static final org.apache.thrift.protocol.TField USERNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("username", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField SCOPE_FIELD_DESC = new org.apache.thrift.protocol.TField("scope", org.apache.thrift.protocol.TType.I32, (short)2);
+ private static final org.apache.thrift.protocol.TField ACTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("actions", org.apache.thrift.protocol.TType.STRING, (short)4);
+ 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)5);
+ private static final org.apache.thrift.protocol.TField NS_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("nsName", org.apache.thrift.protocol.TType.STRING, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TAccessControlEntityStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TAccessControlEntityTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String username; // required
+ /**
+ *
+ * @see TPermissionScope
+ */
+ public @org.apache.thrift.annotation.Nullable TPermissionScope scope; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String actions; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String tableName; // optional
+ public @org.apache.thrift.annotation.Nullable java.lang.String nsName; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ USERNAME((short)1, "username"),
+ /**
+ *
+ * @see TPermissionScope
+ */
+ SCOPE((short)2, "scope"),
+ ACTIONS((short)4, "actions"),
+ TABLE_NAME((short)5, "tableName"),
+ NS_NAME((short)6, "nsName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // USERNAME
+ return USERNAME;
+ case 2: // SCOPE
+ return SCOPE;
+ case 4: // ACTIONS
+ return ACTIONS;
+ case 5: // TABLE_NAME
+ return TABLE_NAME;
+ case 6: // NS_NAME
+ return NS_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.TABLE_NAME,_Fields.NS_NAME};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.USERNAME, new org.apache.thrift.meta_data.FieldMetaData("username", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.SCOPE, new org.apache.thrift.meta_data.FieldMetaData("scope", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TPermissionScope.class)));
+ tmpMap.put(_Fields.ACTIONS, new org.apache.thrift.meta_data.FieldMetaData("actions", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.NS_NAME, new org.apache.thrift.meta_data.FieldMetaData("nsName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TAccessControlEntity.class, metaDataMap);
+ }
+
+ public TAccessControlEntity() {
+ }
+
+ public TAccessControlEntity(
+ java.lang.String username,
+ TPermissionScope scope,
+ java.lang.String actions)
+ {
+ this();
+ this.username = username;
+ this.scope = scope;
+ this.actions = actions;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TAccessControlEntity(TAccessControlEntity other) {
+ if (other.isSetUsername()) {
+ this.username = other.username;
+ }
+ if (other.isSetScope()) {
+ this.scope = other.scope;
+ }
+ if (other.isSetActions()) {
+ this.actions = other.actions;
+ }
+ if (other.isSetTableName()) {
+ this.tableName = other.tableName;
+ }
+ if (other.isSetNsName()) {
+ this.nsName = other.nsName;
+ }
+ }
+
+ public TAccessControlEntity deepCopy() {
+ return new TAccessControlEntity(this);
+ }
+
+ @Override
+ public void clear() {
+ this.username = null;
+ this.scope = null;
+ this.actions = null;
+ this.tableName = null;
+ this.nsName = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getUsername() {
+ return this.username;
+ }
+
+ public TAccessControlEntity setUsername(@org.apache.thrift.annotation.Nullable java.lang.String username) {
+ this.username = username;
+ return this;
+ }
+
+ public void unsetUsername() {
+ this.username = null;
+ }
+
+ /** Returns true if field username is set (has been assigned a value) and false otherwise */
+ public boolean isSetUsername() {
+ return this.username != null;
+ }
+
+ public void setUsernameIsSet(boolean value) {
+ if (!value) {
+ this.username = null;
+ }
+ }
+
+ /**
+ *
+ * @see TPermissionScope
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TPermissionScope getScope() {
+ return this.scope;
+ }
+
+ /**
+ *
+ * @see TPermissionScope
+ */
+ public TAccessControlEntity setScope(@org.apache.thrift.annotation.Nullable TPermissionScope scope) {
+ this.scope = scope;
+ return this;
+ }
+
+ public void unsetScope() {
+ this.scope = null;
+ }
+
+ /** Returns true if field scope is set (has been assigned a value) and false otherwise */
+ public boolean isSetScope() {
+ return this.scope != null;
+ }
+
+ public void setScopeIsSet(boolean value) {
+ if (!value) {
+ this.scope = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getActions() {
+ return this.actions;
+ }
+
+ public TAccessControlEntity setActions(@org.apache.thrift.annotation.Nullable java.lang.String actions) {
+ this.actions = actions;
+ return this;
+ }
+
+ public void unsetActions() {
+ this.actions = null;
+ }
+
+ /** Returns true if field actions is set (has been assigned a value) and false otherwise */
+ public boolean isSetActions() {
+ return this.actions != null;
+ }
+
+ public void setActionsIsSet(boolean value) {
+ if (!value) {
+ this.actions = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getTableName() {
+ return this.tableName;
+ }
+
+ public TAccessControlEntity setTableName(@org.apache.thrift.annotation.Nullable java.lang.String tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getNsName() {
+ return this.nsName;
+ }
+
+ public TAccessControlEntity setNsName(@org.apache.thrift.annotation.Nullable java.lang.String nsName) {
+ this.nsName = nsName;
+ return this;
+ }
+
+ public void unsetNsName() {
+ this.nsName = null;
+ }
+
+ /** Returns true if field nsName is set (has been assigned a value) and false otherwise */
+ public boolean isSetNsName() {
+ return this.nsName != null;
+ }
+
+ public void setNsNameIsSet(boolean value) {
+ if (!value) {
+ this.nsName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case USERNAME:
+ if (value == null) {
+ unsetUsername();
+ } else {
+ setUsername((java.lang.String)value);
+ }
+ break;
+
+ case SCOPE:
+ if (value == null) {
+ unsetScope();
+ } else {
+ setScope((TPermissionScope)value);
+ }
+ break;
+
+ case ACTIONS:
+ if (value == null) {
+ unsetActions();
+ } else {
+ setActions((java.lang.String)value);
+ }
+ break;
+
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((java.lang.String)value);
+ }
+ break;
+
+ case NS_NAME:
+ if (value == null) {
+ unsetNsName();
+ } else {
+ setNsName((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case USERNAME:
+ return getUsername();
+
+ case SCOPE:
+ return getScope();
+
+ case ACTIONS:
+ return getActions();
+
+ case TABLE_NAME:
+ return getTableName();
+
+ case NS_NAME:
+ return getNsName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case USERNAME:
+ return isSetUsername();
+ case SCOPE:
+ return isSetScope();
+ case ACTIONS:
+ return isSetActions();
+ case TABLE_NAME:
+ return isSetTableName();
+ case NS_NAME:
+ return isSetNsName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TAccessControlEntity)
+ return this.equals((TAccessControlEntity)that);
+ return false;
+ }
+
+ public boolean equals(TAccessControlEntity that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_username = true && this.isSetUsername();
+ boolean that_present_username = true && that.isSetUsername();
+ if (this_present_username || that_present_username) {
+ if (!(this_present_username && that_present_username))
+ return false;
+ if (!this.username.equals(that.username))
+ return false;
+ }
+
+ boolean this_present_scope = true && this.isSetScope();
+ boolean that_present_scope = true && that.isSetScope();
+ if (this_present_scope || that_present_scope) {
+ if (!(this_present_scope && that_present_scope))
+ return false;
+ if (!this.scope.equals(that.scope))
+ return false;
+ }
+
+ boolean this_present_actions = true && this.isSetActions();
+ boolean that_present_actions = true && that.isSetActions();
+ if (this_present_actions || that_present_actions) {
+ if (!(this_present_actions && that_present_actions))
+ return false;
+ if (!this.actions.equals(that.actions))
+ return false;
+ }
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_nsName = true && this.isSetNsName();
+ boolean that_present_nsName = true && that.isSetNsName();
+ if (this_present_nsName || that_present_nsName) {
+ if (!(this_present_nsName && that_present_nsName))
+ return false;
+ if (!this.nsName.equals(that.nsName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetUsername()) ? 131071 : 524287);
+ if (isSetUsername())
+ hashCode = hashCode * 8191 + username.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetScope()) ? 131071 : 524287);
+ if (isSetScope())
+ hashCode = hashCode * 8191 + scope.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetActions()) ? 131071 : 524287);
+ if (isSetActions())
+ hashCode = hashCode * 8191 + actions.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetNsName()) ? 131071 : 524287);
+ if (isSetNsName())
+ hashCode = hashCode * 8191 + nsName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TAccessControlEntity other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetUsername(), other.isSetUsername());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetUsername()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.username, other.username);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetScope(), other.isSetScope());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetScope()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scope, other.scope);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetActions(), other.isSetActions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetActions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.actions, other.actions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetNsName(), other.isSetNsName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNsName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nsName, other.nsName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TAccessControlEntity(");
+ boolean first = true;
+
+ sb.append("username:");
+ if (this.username == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.username);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("scope:");
+ if (this.scope == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.scope);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("actions:");
+ if (this.actions == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.actions);
+ }
+ first = false;
+ if (isSetTableName()) {
+ if (!first) sb.append(", ");
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ }
+ if (isSetNsName()) {
+ if (!first) sb.append(", ");
+ sb.append("nsName:");
+ if (this.nsName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.nsName);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (username == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'username' was not present! Struct: " + toString());
+ }
+ if (scope == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'scope' was not present! Struct: " + toString());
+ }
+ if (actions == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'actions' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TAccessControlEntityStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAccessControlEntityStandardScheme getScheme() {
+ return new TAccessControlEntityStandardScheme();
+ }
+ }
+
+ private static class TAccessControlEntityStandardScheme extends org.apache.thrift.scheme.StandardScheme<TAccessControlEntity> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // USERNAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.username = iprot.readString();
+ struct.setUsernameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // SCOPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.scope = org.apache.hadoop.hbase.thrift2.generated.TPermissionScope.findByValue(iprot.readI32());
+ struct.setScopeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ACTIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.actions = iprot.readString();
+ struct.setActionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // NS_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.nsName = iprot.readString();
+ struct.setNsNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.username != null) {
+ oprot.writeFieldBegin(USERNAME_FIELD_DESC);
+ oprot.writeString(struct.username);
+ oprot.writeFieldEnd();
+ }
+ if (struct.scope != null) {
+ oprot.writeFieldBegin(SCOPE_FIELD_DESC);
+ oprot.writeI32(struct.scope.getValue());
+ oprot.writeFieldEnd();
+ }
+ if (struct.actions != null) {
+ oprot.writeFieldBegin(ACTIONS_FIELD_DESC);
+ oprot.writeString(struct.actions);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tableName != null) {
+ if (struct.isSetTableName()) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeString(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.nsName != null) {
+ if (struct.isSetNsName()) {
+ oprot.writeFieldBegin(NS_NAME_FIELD_DESC);
+ oprot.writeString(struct.nsName);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TAccessControlEntityTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAccessControlEntityTupleScheme getScheme() {
+ return new TAccessControlEntityTupleScheme();
+ }
+ }
+
+ private static class TAccessControlEntityTupleScheme extends org.apache.thrift.scheme.TupleScheme<TAccessControlEntity> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.username);
+ oprot.writeI32(struct.scope.getValue());
+ oprot.writeString(struct.actions);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetNsName()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetTableName()) {
+ oprot.writeString(struct.tableName);
+ }
+ if (struct.isSetNsName()) {
+ oprot.writeString(struct.nsName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TAccessControlEntity struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.username = iprot.readString();
+ struct.setUsernameIsSet(true);
+ struct.scope = org.apache.hadoop.hbase.thrift2.generated.TPermissionScope.findByValue(iprot.readI32());
+ struct.setScopeIsSet(true);
+ struct.actions = iprot.readString();
+ struct.setActionsIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.nsName = iprot.readString();
+ struct.setNsNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAppend.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAppend.java
new file mode 100644
index 0000000..33ccfd5
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAppend.java
@@ -0,0 +1,1038 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TAppend implements org.apache.thrift.TBase<TAppend, TAppend._Fields>, java.io.Serializable, Cloneable, Comparable<TAppend> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAppend");
+
+ 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)1);
+ 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)2);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)3);
+ private static final org.apache.thrift.protocol.TField DURABILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("durability", org.apache.thrift.protocol.TType.I32, (short)4);
+ private static final org.apache.thrift.protocol.TField CELL_VISIBILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("cellVisibility", org.apache.thrift.protocol.TType.STRUCT, (short)5);
+ private static final org.apache.thrift.protocol.TField RETURN_RESULTS_FIELD_DESC = new org.apache.thrift.protocol.TField("returnResults", org.apache.thrift.protocol.TType.BOOL, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TAppendStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TAppendTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumnValue> columns; // required
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ /**
+ *
+ * @see TDurability
+ */
+ public @org.apache.thrift.annotation.Nullable TDurability durability; // optional
+ public @org.apache.thrift.annotation.Nullable TCellVisibility cellVisibility; // optional
+ public boolean returnResults; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ COLUMNS((short)2, "columns"),
+ ATTRIBUTES((short)3, "attributes"),
+ /**
+ *
+ * @see TDurability
+ */
+ DURABILITY((short)4, "durability"),
+ CELL_VISIBILITY((short)5, "cellVisibility"),
+ RETURN_RESULTS((short)6, "returnResults");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // COLUMNS
+ return COLUMNS;
+ case 3: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 4: // DURABILITY
+ return DURABILITY;
+ case 5: // CELL_VISIBILITY
+ return CELL_VISIBILITY;
+ case 6: // RETURN_RESULTS
+ return RETURN_RESULTS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __RETURNRESULTS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.ATTRIBUTES,_Fields.DURABILITY,_Fields.CELL_VISIBILITY,_Fields.RETURN_RESULTS};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TColumnValue.class))));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.DURABILITY, new org.apache.thrift.meta_data.FieldMetaData("durability", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDurability.class)));
+ tmpMap.put(_Fields.CELL_VISIBILITY, new org.apache.thrift.meta_data.FieldMetaData("cellVisibility", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCellVisibility.class)));
+ tmpMap.put(_Fields.RETURN_RESULTS, new org.apache.thrift.meta_data.FieldMetaData("returnResults", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TAppend.class, metaDataMap);
+ }
+
+ public TAppend() {
+ }
+
+ public TAppend(
+ java.nio.ByteBuffer row,
+ java.util.List<TColumnValue> columns)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.columns = columns;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TAppend(TAppend other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<TColumnValue> __this__columns = new java.util.ArrayList<TColumnValue>(other.columns.size());
+ for (TColumnValue other_element : other.columns) {
+ __this__columns.add(new TColumnValue(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetDurability()) {
+ this.durability = other.durability;
+ }
+ if (other.isSetCellVisibility()) {
+ this.cellVisibility = new TCellVisibility(other.cellVisibility);
+ }
+ this.returnResults = other.returnResults;
+ }
+
+ public TAppend deepCopy() {
+ return new TAppend(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.columns = null;
+ this.attributes = null;
+ this.durability = null;
+ this.cellVisibility = null;
+ setReturnResultsIsSet(false);
+ this.returnResults = false;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TAppend setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TAppend setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumnValue> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(TColumnValue elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<TColumnValue>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumnValue> getColumns() {
+ return this.columns;
+ }
+
+ public TAppend setColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumnValue> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TAppend setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDurability getDurability() {
+ return this.durability;
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ public TAppend setDurability(@org.apache.thrift.annotation.Nullable TDurability durability) {
+ this.durability = durability;
+ return this;
+ }
+
+ public void unsetDurability() {
+ this.durability = null;
+ }
+
+ /** Returns true if field durability is set (has been assigned a value) and false otherwise */
+ public boolean isSetDurability() {
+ return this.durability != null;
+ }
+
+ public void setDurabilityIsSet(boolean value) {
+ if (!value) {
+ this.durability = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TCellVisibility getCellVisibility() {
+ return this.cellVisibility;
+ }
+
+ public TAppend setCellVisibility(@org.apache.thrift.annotation.Nullable TCellVisibility cellVisibility) {
+ this.cellVisibility = cellVisibility;
+ return this;
+ }
+
+ public void unsetCellVisibility() {
+ this.cellVisibility = null;
+ }
+
+ /** Returns true if field cellVisibility is set (has been assigned a value) and false otherwise */
+ public boolean isSetCellVisibility() {
+ return this.cellVisibility != null;
+ }
+
+ public void setCellVisibilityIsSet(boolean value) {
+ if (!value) {
+ this.cellVisibility = null;
+ }
+ }
+
+ public boolean isReturnResults() {
+ return this.returnResults;
+ }
+
+ public TAppend setReturnResults(boolean returnResults) {
+ this.returnResults = returnResults;
+ setReturnResultsIsSet(true);
+ return this;
+ }
+
+ public void unsetReturnResults() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __RETURNRESULTS_ISSET_ID);
+ }
+
+ /** Returns true if field returnResults is set (has been assigned a value) and false otherwise */
+ public boolean isSetReturnResults() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __RETURNRESULTS_ISSET_ID);
+ }
+
+ public void setReturnResultsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __RETURNRESULTS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<TColumnValue>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case DURABILITY:
+ if (value == null) {
+ unsetDurability();
+ } else {
+ setDurability((TDurability)value);
+ }
+ break;
+
+ case CELL_VISIBILITY:
+ if (value == null) {
+ unsetCellVisibility();
+ } else {
+ setCellVisibility((TCellVisibility)value);
+ }
+ break;
+
+ case RETURN_RESULTS:
+ if (value == null) {
+ unsetReturnResults();
+ } else {
+ setReturnResults((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case DURABILITY:
+ return getDurability();
+
+ case CELL_VISIBILITY:
+ return getCellVisibility();
+
+ case RETURN_RESULTS:
+ return isReturnResults();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case DURABILITY:
+ return isSetDurability();
+ case CELL_VISIBILITY:
+ return isSetCellVisibility();
+ case RETURN_RESULTS:
+ return isSetReturnResults();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TAppend)
+ return this.equals((TAppend)that);
+ return false;
+ }
+
+ public boolean equals(TAppend that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_durability = true && this.isSetDurability();
+ boolean that_present_durability = true && that.isSetDurability();
+ if (this_present_durability || that_present_durability) {
+ if (!(this_present_durability && that_present_durability))
+ return false;
+ if (!this.durability.equals(that.durability))
+ return false;
+ }
+
+ boolean this_present_cellVisibility = true && this.isSetCellVisibility();
+ boolean that_present_cellVisibility = true && that.isSetCellVisibility();
+ if (this_present_cellVisibility || that_present_cellVisibility) {
+ if (!(this_present_cellVisibility && that_present_cellVisibility))
+ return false;
+ if (!this.cellVisibility.equals(that.cellVisibility))
+ return false;
+ }
+
+ boolean this_present_returnResults = true && this.isSetReturnResults();
+ boolean that_present_returnResults = true && that.isSetReturnResults();
+ if (this_present_returnResults || that_present_returnResults) {
+ if (!(this_present_returnResults && that_present_returnResults))
+ return false;
+ if (this.returnResults != that.returnResults)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetDurability()) ? 131071 : 524287);
+ if (isSetDurability())
+ hashCode = hashCode * 8191 + durability.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetCellVisibility()) ? 131071 : 524287);
+ if (isSetCellVisibility())
+ hashCode = hashCode * 8191 + cellVisibility.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetReturnResults()) ? 131071 : 524287);
+ if (isSetReturnResults())
+ hashCode = hashCode * 8191 + ((returnResults) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TAppend other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDurability(), other.isSetDurability());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDurability()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.durability, other.durability);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCellVisibility(), other.isSetCellVisibility());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCellVisibility()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cellVisibility, other.cellVisibility);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetReturnResults(), other.isSetReturnResults());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReturnResults()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.returnResults, other.returnResults);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TAppend(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columns);
+ }
+ first = false;
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetDurability()) {
+ if (!first) sb.append(", ");
+ sb.append("durability:");
+ if (this.durability == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.durability);
+ }
+ first = false;
+ }
+ if (isSetCellVisibility()) {
+ if (!first) sb.append(", ");
+ sb.append("cellVisibility:");
+ if (this.cellVisibility == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.cellVisibility);
+ }
+ first = false;
+ }
+ if (isSetReturnResults()) {
+ if (!first) sb.append(", ");
+ sb.append("returnResults:");
+ sb.append(this.returnResults);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ if (columns == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'columns' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (cellVisibility != null) {
+ cellVisibility.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TAppendStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAppendStandardScheme getScheme() {
+ return new TAppendStandardScheme();
+ }
+ }
+
+ private static class TAppendStandardScheme extends org.apache.thrift.scheme.StandardScheme<TAppend> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TAppend struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<TColumnValue>(_list88.size);
+ @org.apache.thrift.annotation.Nullable TColumnValue _elem89;
+ for (int _i90 = 0; _i90 < _list88.size; ++_i90)
+ {
+ _elem89 = new TColumnValue();
+ _elem89.read(iprot);
+ struct.columns.add(_elem89);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map91 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map91.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key92;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val93;
+ for (int _i94 = 0; _i94 < _map91.size; ++_i94)
+ {
+ _key92 = iprot.readBinary();
+ _val93 = iprot.readBinary();
+ struct.attributes.put(_key92, _val93);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // DURABILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // CELL_VISIBILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.cellVisibility = new TCellVisibility();
+ struct.cellVisibility.read(iprot);
+ struct.setCellVisibilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // RETURN_RESULTS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.returnResults = iprot.readBool();
+ struct.setReturnResultsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TAppend struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+ for (TColumnValue _iter95 : struct.columns)
+ {
+ _iter95.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter96 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter96.getKey());
+ oprot.writeBinary(_iter96.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.durability != null) {
+ if (struct.isSetDurability()) {
+ oprot.writeFieldBegin(DURABILITY_FIELD_DESC);
+ oprot.writeI32(struct.durability.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.cellVisibility != null) {
+ if (struct.isSetCellVisibility()) {
+ oprot.writeFieldBegin(CELL_VISIBILITY_FIELD_DESC);
+ struct.cellVisibility.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetReturnResults()) {
+ oprot.writeFieldBegin(RETURN_RESULTS_FIELD_DESC);
+ oprot.writeBool(struct.returnResults);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TAppendTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAppendTupleScheme getScheme() {
+ return new TAppendTupleScheme();
+ }
+ }
+
+ private static class TAppendTupleScheme extends org.apache.thrift.scheme.TupleScheme<TAppend> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.row);
+ {
+ oprot.writeI32(struct.columns.size());
+ for (TColumnValue _iter97 : struct.columns)
+ {
+ _iter97.write(oprot);
+ }
+ }
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetAttributes()) {
+ optionals.set(0);
+ }
+ if (struct.isSetDurability()) {
+ optionals.set(1);
+ }
+ if (struct.isSetCellVisibility()) {
+ optionals.set(2);
+ }
+ if (struct.isSetReturnResults()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter98 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter98.getKey());
+ oprot.writeBinary(_iter98.getValue());
+ }
+ }
+ }
+ if (struct.isSetDurability()) {
+ oprot.writeI32(struct.durability.getValue());
+ }
+ if (struct.isSetCellVisibility()) {
+ struct.cellVisibility.write(oprot);
+ }
+ if (struct.isSetReturnResults()) {
+ oprot.writeBool(struct.returnResults);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list99 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columns = new java.util.ArrayList<TColumnValue>(_list99.size);
+ @org.apache.thrift.annotation.Nullable TColumnValue _elem100;
+ for (int _i101 = 0; _i101 < _list99.size; ++_i101)
+ {
+ _elem100 = new TColumnValue();
+ _elem100.read(iprot);
+ struct.columns.add(_elem100);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TMap _map102 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map102.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key103;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val104;
+ for (int _i105 = 0; _i105 < _map102.size; ++_i105)
+ {
+ _key103 = iprot.readBinary();
+ _val104 = iprot.readBinary();
+ struct.attributes.put(_key103, _val104);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.cellVisibility = new TCellVisibility();
+ struct.cellVisibility.read(iprot);
+ struct.setCellVisibilityIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.returnResults = iprot.readBool();
+ struct.setReturnResultsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAuthorization.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAuthorization.java
new file mode 100644
index 0000000..7962bfa
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAuthorization.java
@@ -0,0 +1,423 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TAuthorization implements org.apache.thrift.TBase<TAuthorization, TAuthorization._Fields>, java.io.Serializable, Cloneable, Comparable<TAuthorization> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAuthorization");
+
+ private static final org.apache.thrift.protocol.TField LABELS_FIELD_DESC = new org.apache.thrift.protocol.TField("labels", org.apache.thrift.protocol.TType.LIST, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TAuthorizationStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TAuthorizationTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> labels; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ LABELS((short)1, "labels");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // LABELS
+ return LABELS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.LABELS};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.LABELS, new org.apache.thrift.meta_data.FieldMetaData("labels", 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))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TAuthorization.class, metaDataMap);
+ }
+
+ public TAuthorization() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TAuthorization(TAuthorization other) {
+ if (other.isSetLabels()) {
+ java.util.List<java.lang.String> __this__labels = new java.util.ArrayList<java.lang.String>(other.labels);
+ this.labels = __this__labels;
+ }
+ }
+
+ public TAuthorization deepCopy() {
+ return new TAuthorization(this);
+ }
+
+ @Override
+ public void clear() {
+ this.labels = null;
+ }
+
+ public int getLabelsSize() {
+ return (this.labels == null) ? 0 : this.labels.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.lang.String> getLabelsIterator() {
+ return (this.labels == null) ? null : this.labels.iterator();
+ }
+
+ public void addToLabels(java.lang.String elem) {
+ if (this.labels == null) {
+ this.labels = new java.util.ArrayList<java.lang.String>();
+ }
+ this.labels.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.lang.String> getLabels() {
+ return this.labels;
+ }
+
+ public TAuthorization setLabels(@org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> labels) {
+ this.labels = labels;
+ return this;
+ }
+
+ public void unsetLabels() {
+ this.labels = null;
+ }
+
+ /** Returns true if field labels is set (has been assigned a value) and false otherwise */
+ public boolean isSetLabels() {
+ return this.labels != null;
+ }
+
+ public void setLabelsIsSet(boolean value) {
+ if (!value) {
+ this.labels = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case LABELS:
+ if (value == null) {
+ unsetLabels();
+ } else {
+ setLabels((java.util.List<java.lang.String>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case LABELS:
+ return getLabels();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case LABELS:
+ return isSetLabels();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TAuthorization)
+ return this.equals((TAuthorization)that);
+ return false;
+ }
+
+ public boolean equals(TAuthorization that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_labels = true && this.isSetLabels();
+ boolean that_present_labels = true && that.isSetLabels();
+ if (this_present_labels || that_present_labels) {
+ if (!(this_present_labels && that_present_labels))
+ return false;
+ if (!this.labels.equals(that.labels))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetLabels()) ? 131071 : 524287);
+ if (isSetLabels())
+ hashCode = hashCode * 8191 + labels.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TAuthorization other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetLabels(), other.isSetLabels());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetLabels()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.labels, other.labels);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TAuthorization(");
+ boolean first = true;
+
+ if (isSetLabels()) {
+ sb.append("labels:");
+ if (this.labels == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.labels);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TAuthorizationStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAuthorizationStandardScheme getScheme() {
+ return new TAuthorizationStandardScheme();
+ }
+ }
+
+ private static class TAuthorizationStandardScheme extends org.apache.thrift.scheme.StandardScheme<TAuthorization> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TAuthorization struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // LABELS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list8 = iprot.readListBegin();
+ struct.labels = new java.util.ArrayList<java.lang.String>(_list8.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem9;
+ for (int _i10 = 0; _i10 < _list8.size; ++_i10)
+ {
+ _elem9 = iprot.readString();
+ struct.labels.add(_elem9);
+ }
+ iprot.readListEnd();
+ }
+ struct.setLabelsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TAuthorization struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.labels != null) {
+ if (struct.isSetLabels()) {
+ oprot.writeFieldBegin(LABELS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.labels.size()));
+ for (java.lang.String _iter11 : struct.labels)
+ {
+ oprot.writeString(_iter11);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TAuthorizationTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TAuthorizationTupleScheme getScheme() {
+ return new TAuthorizationTupleScheme();
+ }
+ }
+
+ private static class TAuthorizationTupleScheme extends org.apache.thrift.scheme.TupleScheme<TAuthorization> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TAuthorization struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetLabels()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetLabels()) {
+ {
+ oprot.writeI32(struct.labels.size());
+ for (java.lang.String _iter12 : struct.labels)
+ {
+ oprot.writeString(_iter12);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TAuthorization struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list13 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.labels = new java.util.ArrayList<java.lang.String>(_list13.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem14;
+ for (int _i15 = 0; _i15 < _list13.size; ++_i15)
+ {
+ _elem14 = iprot.readString();
+ struct.labels.add(_elem14);
+ }
+ }
+ struct.setLabelsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TBloomFilterType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TBloomFilterType.java
new file mode 100644
index 0000000..35bcfd5
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TBloomFilterType.java
@@ -0,0 +1,65 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.regionserver.BloomType
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TBloomFilterType implements org.apache.thrift.TEnum {
+ /**
+ * Bloomfilters disabled
+ */
+ NONE(0),
+ /**
+ * Bloom enabled with Table row as Key
+ */
+ ROW(1),
+ /**
+ * Bloom enabled with Table row & column (family+qualifier) as Key
+ */
+ ROWCOL(2),
+ /**
+ * Bloom enabled with Table row prefix as Key, specify the length of the prefix
+ */
+ ROWPREFIX_FIXED_LENGTH(3);
+
+ private final int value;
+
+ private TBloomFilterType(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TBloomFilterType findByValue(int value) {
+ switch (value) {
+ case 0:
+ return NONE;
+ case 1:
+ return ROW;
+ case 2:
+ return ROWCOL;
+ case 3:
+ return ROWPREFIX_FIXED_LENGTH;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCellVisibility.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCellVisibility.java
new file mode 100644
index 0000000..7a29bd7
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCellVisibility.java
@@ -0,0 +1,373 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TCellVisibility implements org.apache.thrift.TBase<TCellVisibility, TCellVisibility._Fields>, java.io.Serializable, Cloneable, Comparable<TCellVisibility> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TCellVisibility");
+
+ private static final org.apache.thrift.protocol.TField EXPRESSION_FIELD_DESC = new org.apache.thrift.protocol.TField("expression", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TCellVisibilityStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TCellVisibilityTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String expression; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ EXPRESSION((short)1, "expression");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // EXPRESSION
+ return EXPRESSION;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.EXPRESSION};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.EXPRESSION, new org.apache.thrift.meta_data.FieldMetaData("expression", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TCellVisibility.class, metaDataMap);
+ }
+
+ public TCellVisibility() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TCellVisibility(TCellVisibility other) {
+ if (other.isSetExpression()) {
+ this.expression = other.expression;
+ }
+ }
+
+ public TCellVisibility deepCopy() {
+ return new TCellVisibility(this);
+ }
+
+ @Override
+ public void clear() {
+ this.expression = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getExpression() {
+ return this.expression;
+ }
+
+ public TCellVisibility setExpression(@org.apache.thrift.annotation.Nullable java.lang.String expression) {
+ this.expression = expression;
+ return this;
+ }
+
+ public void unsetExpression() {
+ this.expression = null;
+ }
+
+ /** Returns true if field expression is set (has been assigned a value) and false otherwise */
+ public boolean isSetExpression() {
+ return this.expression != null;
+ }
+
+ public void setExpressionIsSet(boolean value) {
+ if (!value) {
+ this.expression = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case EXPRESSION:
+ if (value == null) {
+ unsetExpression();
+ } else {
+ setExpression((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case EXPRESSION:
+ return getExpression();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case EXPRESSION:
+ return isSetExpression();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TCellVisibility)
+ return this.equals((TCellVisibility)that);
+ return false;
+ }
+
+ public boolean equals(TCellVisibility that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_expression = true && this.isSetExpression();
+ boolean that_present_expression = true && that.isSetExpression();
+ if (this_present_expression || that_present_expression) {
+ if (!(this_present_expression && that_present_expression))
+ return false;
+ if (!this.expression.equals(that.expression))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetExpression()) ? 131071 : 524287);
+ if (isSetExpression())
+ hashCode = hashCode * 8191 + expression.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TCellVisibility other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetExpression(), other.isSetExpression());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetExpression()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.expression, other.expression);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TCellVisibility(");
+ boolean first = true;
+
+ if (isSetExpression()) {
+ sb.append("expression:");
+ if (this.expression == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.expression);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TCellVisibilityStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TCellVisibilityStandardScheme getScheme() {
+ return new TCellVisibilityStandardScheme();
+ }
+ }
+
+ private static class TCellVisibilityStandardScheme extends org.apache.thrift.scheme.StandardScheme<TCellVisibility> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TCellVisibility struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // EXPRESSION
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.expression = iprot.readString();
+ struct.setExpressionIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TCellVisibility struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.expression != null) {
+ if (struct.isSetExpression()) {
+ oprot.writeFieldBegin(EXPRESSION_FIELD_DESC);
+ oprot.writeString(struct.expression);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TCellVisibilityTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TCellVisibilityTupleScheme getScheme() {
+ return new TCellVisibilityTupleScheme();
+ }
+ }
+
+ private static class TCellVisibilityTupleScheme extends org.apache.thrift.scheme.TupleScheme<TCellVisibility> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TCellVisibility struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetExpression()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetExpression()) {
+ oprot.writeString(struct.expression);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TCellVisibility struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.expression = iprot.readString();
+ struct.setExpressionIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumn.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumn.java
new file mode 100644
index 0000000..90f7cde
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumn.java
@@ -0,0 +1,613 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Addresses a single cell or multiple cells
+ * in a HBase table by column family and optionally
+ * a column qualifier and timestamp
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TColumn implements org.apache.thrift.TBase<TColumn, TColumn._Fields>, java.io.Serializable, Cloneable, Comparable<TColumn> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumn");
+
+ private static final org.apache.thrift.protocol.TField FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", 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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TColumnStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TColumnTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier; // optional
+ public long timestamp; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ FAMILY((short)1, "family"),
+ QUALIFIER((short)2, "qualifier"),
+ TIMESTAMP((short)3, "timestamp");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // FAMILY
+ return FAMILY;
+ case 2: // QUALIFIER
+ return QUALIFIER;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.QUALIFIER,_Fields.TIMESTAMP};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ 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)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TColumn.class, metaDataMap);
+ }
+
+ public TColumn() {
+ }
+
+ public TColumn(
+ java.nio.ByteBuffer family)
+ {
+ this();
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TColumn(TColumn other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetFamily()) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
+ }
+ if (other.isSetQualifier()) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
+ }
+ this.timestamp = other.timestamp;
+ }
+
+ public TColumn deepCopy() {
+ return new TColumn(this);
+ }
+
+ @Override
+ public void clear() {
+ this.family = null;
+ this.qualifier = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ }
+
+ public byte[] getFamily() {
+ setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
+ return family == null ? null : family.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFamily() {
+ return org.apache.thrift.TBaseHelper.copyBinary(family);
+ }
+
+ public TColumn setFamily(byte[] family) {
+ this.family = family == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(family.clone());
+ return this;
+ }
+
+ public TColumn setFamily(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ return this;
+ }
+
+ public void unsetFamily() {
+ this.family = null;
+ }
+
+ /** Returns true if field family is set (has been assigned a value) and false otherwise */
+ public boolean isSetFamily() {
+ return this.family != null;
+ }
+
+ public void setFamilyIsSet(boolean value) {
+ if (!value) {
+ this.family = null;
+ }
+ }
+
+ public byte[] getQualifier() {
+ setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
+ return qualifier == null ? null : qualifier.array();
+ }
+
+ public java.nio.ByteBuffer bufferForQualifier() {
+ return org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ public TColumn setQualifier(byte[] qualifier) {
+ this.qualifier = qualifier == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(qualifier.clone());
+ return this;
+ }
+
+ public TColumn setQualifier(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ return this;
+ }
+
+ public void unsetQualifier() {
+ this.qualifier = null;
+ }
+
+ /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
+ public boolean isSetQualifier() {
+ return this.qualifier != null;
+ }
+
+ public void setQualifierIsSet(boolean value) {
+ if (!value) {
+ this.qualifier = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public TColumn setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case FAMILY:
+ if (value == null) {
+ unsetFamily();
+ } else {
+ if (value instanceof byte[]) {
+ setFamily((byte[])value);
+ } else {
+ setFamily((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case QUALIFIER:
+ if (value == null) {
+ unsetQualifier();
+ } else {
+ if (value instanceof byte[]) {
+ setQualifier((byte[])value);
+ } else {
+ setQualifier((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case FAMILY:
+ return getFamily();
+
+ case QUALIFIER:
+ return getQualifier();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case FAMILY:
+ return isSetFamily();
+ case QUALIFIER:
+ return isSetQualifier();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TColumn)
+ return this.equals((TColumn)that);
+ return false;
+ }
+
+ public boolean equals(TColumn that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_family = true && this.isSetFamily();
+ boolean that_present_family = true && that.isSetFamily();
+ if (this_present_family || that_present_family) {
+ if (!(this_present_family && that_present_family))
+ return false;
+ if (!this.family.equals(that.family))
+ return false;
+ }
+
+ boolean this_present_qualifier = true && this.isSetQualifier();
+ boolean that_present_qualifier = true && that.isSetQualifier();
+ if (this_present_qualifier || that_present_qualifier) {
+ if (!(this_present_qualifier && that_present_qualifier))
+ return false;
+ if (!this.qualifier.equals(that.qualifier))
+ return false;
+ }
+
+ boolean this_present_timestamp = true && this.isSetTimestamp();
+ boolean that_present_timestamp = true && that.isSetTimestamp();
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetFamily()) ? 131071 : 524287);
+ if (isSetFamily())
+ hashCode = hashCode * 8191 + family.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetQualifier()) ? 131071 : 524287);
+ if (isSetQualifier())
+ hashCode = hashCode * 8191 + qualifier.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTimestamp()) ? 131071 : 524287);
+ if (isSetTimestamp())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TColumn other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetFamily(), other.isSetFamily());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFamily()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, other.family);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQualifier(), other.isSetQualifier());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQualifier()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, other.qualifier);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TColumn(");
+ boolean first = true;
+
+ sb.append("family:");
+ if (this.family == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.family, sb);
+ }
+ first = false;
+ if (isSetQualifier()) {
+ if (!first) sb.append(", ");
+ sb.append("qualifier:");
+ if (this.qualifier == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
+ }
+ first = false;
+ }
+ if (isSetTimestamp()) {
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (family == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TColumnStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnStandardScheme getScheme() {
+ return new TColumnStandardScheme();
+ }
+ }
+
+ private static class TColumnStandardScheme extends org.apache.thrift.scheme.StandardScheme<TColumn> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TColumn struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // FAMILY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // QUALIFIER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TColumn struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.family != null) {
+ oprot.writeFieldBegin(FAMILY_FIELD_DESC);
+ oprot.writeBinary(struct.family);
+ oprot.writeFieldEnd();
+ }
+ if (struct.qualifier != null) {
+ if (struct.isSetQualifier()) {
+ oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TColumnTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnTupleScheme getScheme() {
+ return new TColumnTupleScheme();
+ }
+ }
+
+ private static class TColumnTupleScheme extends org.apache.thrift.scheme.TupleScheme<TColumn> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TColumn struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.family);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetQualifier()) {
+ optionals.set(0);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetQualifier()) {
+ oprot.writeBinary(struct.qualifier);
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TColumn struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java
new file mode 100644
index 0000000..0c48ba6
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java
@@ -0,0 +1,2490 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.ColumnFamilyDescriptor
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TColumnFamilyDescriptor implements org.apache.thrift.TBase<TColumnFamilyDescriptor, TColumnFamilyDescriptor._Fields>, java.io.Serializable, Cloneable, Comparable<TColumnFamilyDescriptor> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumnFamilyDescriptor");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)2);
+ private static final org.apache.thrift.protocol.TField CONFIGURATION_FIELD_DESC = new org.apache.thrift.protocol.TField("configuration", org.apache.thrift.protocol.TType.MAP, (short)3);
+ private static final org.apache.thrift.protocol.TField BLOCK_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("blockSize", org.apache.thrift.protocol.TType.I32, (short)4);
+ private static final org.apache.thrift.protocol.TField BLOOMN_FILTER_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomnFilterType", org.apache.thrift.protocol.TType.I32, (short)5);
+ private static final org.apache.thrift.protocol.TField COMPRESSION_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("compressionType", org.apache.thrift.protocol.TType.I32, (short)6);
+ private static final org.apache.thrift.protocol.TField DFS_REPLICATION_FIELD_DESC = new org.apache.thrift.protocol.TField("dfsReplication", org.apache.thrift.protocol.TType.I16, (short)7);
+ private static final org.apache.thrift.protocol.TField DATA_BLOCK_ENCODING_FIELD_DESC = new org.apache.thrift.protocol.TField("dataBlockEncoding", org.apache.thrift.protocol.TType.I32, (short)8);
+ private static final org.apache.thrift.protocol.TField KEEP_DELETED_CELLS_FIELD_DESC = new org.apache.thrift.protocol.TField("keepDeletedCells", org.apache.thrift.protocol.TType.I32, (short)9);
+ private static final org.apache.thrift.protocol.TField MAX_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("maxVersions", org.apache.thrift.protocol.TType.I32, (short)10);
+ private static final org.apache.thrift.protocol.TField MIN_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("minVersions", org.apache.thrift.protocol.TType.I32, (short)11);
+ private static final org.apache.thrift.protocol.TField SCOPE_FIELD_DESC = new org.apache.thrift.protocol.TField("scope", org.apache.thrift.protocol.TType.I32, (short)12);
+ private static final org.apache.thrift.protocol.TField TIME_TO_LIVE_FIELD_DESC = new org.apache.thrift.protocol.TField("timeToLive", org.apache.thrift.protocol.TType.I32, (short)13);
+ private static final org.apache.thrift.protocol.TField BLOCK_CACHE_ENABLED_FIELD_DESC = new org.apache.thrift.protocol.TField("blockCacheEnabled", org.apache.thrift.protocol.TType.BOOL, (short)14);
+ private static final org.apache.thrift.protocol.TField CACHE_BLOOMS_ON_WRITE_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheBloomsOnWrite", org.apache.thrift.protocol.TType.BOOL, (short)15);
+ private static final org.apache.thrift.protocol.TField CACHE_DATA_ON_WRITE_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheDataOnWrite", org.apache.thrift.protocol.TType.BOOL, (short)16);
+ private static final org.apache.thrift.protocol.TField CACHE_INDEXES_ON_WRITE_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheIndexesOnWrite", org.apache.thrift.protocol.TType.BOOL, (short)17);
+ private static final org.apache.thrift.protocol.TField COMPRESS_TAGS_FIELD_DESC = new org.apache.thrift.protocol.TField("compressTags", org.apache.thrift.protocol.TType.BOOL, (short)18);
+ private static final org.apache.thrift.protocol.TField EVICT_BLOCKS_ON_CLOSE_FIELD_DESC = new org.apache.thrift.protocol.TField("evictBlocksOnClose", org.apache.thrift.protocol.TType.BOOL, (short)19);
+ private static final org.apache.thrift.protocol.TField IN_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("inMemory", org.apache.thrift.protocol.TType.BOOL, (short)20);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TColumnFamilyDescriptorStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TColumnFamilyDescriptorTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer name; // required
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.lang.String,java.lang.String> configuration; // optional
+ public int blockSize; // optional
+ /**
+ *
+ * @see TBloomFilterType
+ */
+ public @org.apache.thrift.annotation.Nullable TBloomFilterType bloomnFilterType; // optional
+ /**
+ *
+ * @see TCompressionAlgorithm
+ */
+ public @org.apache.thrift.annotation.Nullable TCompressionAlgorithm compressionType; // optional
+ public short dfsReplication; // optional
+ /**
+ *
+ * @see TDataBlockEncoding
+ */
+ public @org.apache.thrift.annotation.Nullable TDataBlockEncoding dataBlockEncoding; // optional
+ /**
+ *
+ * @see TKeepDeletedCells
+ */
+ public @org.apache.thrift.annotation.Nullable TKeepDeletedCells keepDeletedCells; // optional
+ public int maxVersions; // optional
+ public int minVersions; // optional
+ public int scope; // optional
+ public int timeToLive; // optional
+ public boolean blockCacheEnabled; // optional
+ public boolean cacheBloomsOnWrite; // optional
+ public boolean cacheDataOnWrite; // optional
+ public boolean cacheIndexesOnWrite; // optional
+ public boolean compressTags; // optional
+ public boolean evictBlocksOnClose; // optional
+ public boolean inMemory; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ NAME((short)1, "name"),
+ ATTRIBUTES((short)2, "attributes"),
+ CONFIGURATION((short)3, "configuration"),
+ BLOCK_SIZE((short)4, "blockSize"),
+ /**
+ *
+ * @see TBloomFilterType
+ */
+ BLOOMN_FILTER_TYPE((short)5, "bloomnFilterType"),
+ /**
+ *
+ * @see TCompressionAlgorithm
+ */
+ COMPRESSION_TYPE((short)6, "compressionType"),
+ DFS_REPLICATION((short)7, "dfsReplication"),
+ /**
+ *
+ * @see TDataBlockEncoding
+ */
+ DATA_BLOCK_ENCODING((short)8, "dataBlockEncoding"),
+ /**
+ *
+ * @see TKeepDeletedCells
+ */
+ KEEP_DELETED_CELLS((short)9, "keepDeletedCells"),
+ MAX_VERSIONS((short)10, "maxVersions"),
+ MIN_VERSIONS((short)11, "minVersions"),
+ SCOPE((short)12, "scope"),
+ TIME_TO_LIVE((short)13, "timeToLive"),
+ BLOCK_CACHE_ENABLED((short)14, "blockCacheEnabled"),
+ CACHE_BLOOMS_ON_WRITE((short)15, "cacheBloomsOnWrite"),
+ CACHE_DATA_ON_WRITE((short)16, "cacheDataOnWrite"),
+ CACHE_INDEXES_ON_WRITE((short)17, "cacheIndexesOnWrite"),
+ COMPRESS_TAGS((short)18, "compressTags"),
+ EVICT_BLOCKS_ON_CLOSE((short)19, "evictBlocksOnClose"),
+ IN_MEMORY((short)20, "inMemory");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ case 2: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 3: // CONFIGURATION
+ return CONFIGURATION;
+ case 4: // BLOCK_SIZE
+ return BLOCK_SIZE;
+ case 5: // BLOOMN_FILTER_TYPE
+ return BLOOMN_FILTER_TYPE;
+ case 6: // COMPRESSION_TYPE
+ return COMPRESSION_TYPE;
+ case 7: // DFS_REPLICATION
+ return DFS_REPLICATION;
+ case 8: // DATA_BLOCK_ENCODING
+ return DATA_BLOCK_ENCODING;
+ case 9: // KEEP_DELETED_CELLS
+ return KEEP_DELETED_CELLS;
+ case 10: // MAX_VERSIONS
+ return MAX_VERSIONS;
+ case 11: // MIN_VERSIONS
+ return MIN_VERSIONS;
+ case 12: // SCOPE
+ return SCOPE;
+ case 13: // TIME_TO_LIVE
+ return TIME_TO_LIVE;
+ case 14: // BLOCK_CACHE_ENABLED
+ return BLOCK_CACHE_ENABLED;
+ case 15: // CACHE_BLOOMS_ON_WRITE
+ return CACHE_BLOOMS_ON_WRITE;
+ case 16: // CACHE_DATA_ON_WRITE
+ return CACHE_DATA_ON_WRITE;
+ case 17: // CACHE_INDEXES_ON_WRITE
+ return CACHE_INDEXES_ON_WRITE;
+ case 18: // COMPRESS_TAGS
+ return COMPRESS_TAGS;
+ case 19: // EVICT_BLOCKS_ON_CLOSE
+ return EVICT_BLOCKS_ON_CLOSE;
+ case 20: // IN_MEMORY
+ return IN_MEMORY;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __BLOCKSIZE_ISSET_ID = 0;
+ private static final int __DFSREPLICATION_ISSET_ID = 1;
+ private static final int __MAXVERSIONS_ISSET_ID = 2;
+ private static final int __MINVERSIONS_ISSET_ID = 3;
+ private static final int __SCOPE_ISSET_ID = 4;
+ private static final int __TIMETOLIVE_ISSET_ID = 5;
+ private static final int __BLOCKCACHEENABLED_ISSET_ID = 6;
+ private static final int __CACHEBLOOMSONWRITE_ISSET_ID = 7;
+ private static final int __CACHEDATAONWRITE_ISSET_ID = 8;
+ private static final int __CACHEINDEXESONWRITE_ISSET_ID = 9;
+ private static final int __COMPRESSTAGS_ISSET_ID = 10;
+ private static final int __EVICTBLOCKSONCLOSE_ISSET_ID = 11;
+ private static final int __INMEMORY_ISSET_ID = 12;
+ private short __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.ATTRIBUTES,_Fields.CONFIGURATION,_Fields.BLOCK_SIZE,_Fields.BLOOMN_FILTER_TYPE,_Fields.COMPRESSION_TYPE,_Fields.DFS_REPLICATION,_Fields.DATA_BLOCK_ENCODING,_Fields.KEEP_DELETED_CELLS,_Fields.MAX_VERSIONS,_Fields.MIN_VERSIONS,_Fields.SCOPE,_Fields.TIME_TO_LIVE,_Fields.BLOCK_CACHE_ENABLED,_Fields.CACHE_BLOOMS_ON_WRITE,_Fields.CACHE_DATA_ON_WRITE,_Fields.CACHE_INDEXES_ON_WRITE,_Fields.COMPRESS_TAGS,_Fields.EVICT_BLOCKS_ON_CLOSE,_Fields.IN_MEMORY};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.CONFIGURATION, new org.apache.thrift.meta_data.FieldMetaData("configuration", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+ tmpMap.put(_Fields.BLOCK_SIZE, new org.apache.thrift.meta_data.FieldMetaData("blockSize", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.BLOOMN_FILTER_TYPE, new org.apache.thrift.meta_data.FieldMetaData("bloomnFilterType", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TBloomFilterType.class)));
+ tmpMap.put(_Fields.COMPRESSION_TYPE, new org.apache.thrift.meta_data.FieldMetaData("compressionType", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TCompressionAlgorithm.class)));
+ tmpMap.put(_Fields.DFS_REPLICATION, new org.apache.thrift.meta_data.FieldMetaData("dfsReplication", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16)));
+ tmpMap.put(_Fields.DATA_BLOCK_ENCODING, new org.apache.thrift.meta_data.FieldMetaData("dataBlockEncoding", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDataBlockEncoding.class)));
+ tmpMap.put(_Fields.KEEP_DELETED_CELLS, new org.apache.thrift.meta_data.FieldMetaData("keepDeletedCells", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TKeepDeletedCells.class)));
+ tmpMap.put(_Fields.MAX_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("maxVersions", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.MIN_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("minVersions", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.SCOPE, new org.apache.thrift.meta_data.FieldMetaData("scope", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.TIME_TO_LIVE, new org.apache.thrift.meta_data.FieldMetaData("timeToLive", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.BLOCK_CACHE_ENABLED, new org.apache.thrift.meta_data.FieldMetaData("blockCacheEnabled", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.CACHE_BLOOMS_ON_WRITE, new org.apache.thrift.meta_data.FieldMetaData("cacheBloomsOnWrite", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.CACHE_DATA_ON_WRITE, new org.apache.thrift.meta_data.FieldMetaData("cacheDataOnWrite", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.CACHE_INDEXES_ON_WRITE, new org.apache.thrift.meta_data.FieldMetaData("cacheIndexesOnWrite", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.COMPRESS_TAGS, new org.apache.thrift.meta_data.FieldMetaData("compressTags", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.EVICT_BLOCKS_ON_CLOSE, new org.apache.thrift.meta_data.FieldMetaData("evictBlocksOnClose", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IN_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("inMemory", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TColumnFamilyDescriptor.class, metaDataMap);
+ }
+
+ public TColumnFamilyDescriptor() {
+ }
+
+ public TColumnFamilyDescriptor(
+ java.nio.ByteBuffer name)
+ {
+ this();
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(name);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TColumnFamilyDescriptor(TColumnFamilyDescriptor other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetName()) {
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(other.name);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetConfiguration()) {
+ java.util.Map<java.lang.String,java.lang.String> __this__configuration = new java.util.HashMap<java.lang.String,java.lang.String>(other.configuration);
+ this.configuration = __this__configuration;
+ }
+ this.blockSize = other.blockSize;
+ if (other.isSetBloomnFilterType()) {
+ this.bloomnFilterType = other.bloomnFilterType;
+ }
+ if (other.isSetCompressionType()) {
+ this.compressionType = other.compressionType;
+ }
+ this.dfsReplication = other.dfsReplication;
+ if (other.isSetDataBlockEncoding()) {
+ this.dataBlockEncoding = other.dataBlockEncoding;
+ }
+ if (other.isSetKeepDeletedCells()) {
+ this.keepDeletedCells = other.keepDeletedCells;
+ }
+ this.maxVersions = other.maxVersions;
+ this.minVersions = other.minVersions;
+ this.scope = other.scope;
+ this.timeToLive = other.timeToLive;
+ this.blockCacheEnabled = other.blockCacheEnabled;
+ this.cacheBloomsOnWrite = other.cacheBloomsOnWrite;
+ this.cacheDataOnWrite = other.cacheDataOnWrite;
+ this.cacheIndexesOnWrite = other.cacheIndexesOnWrite;
+ this.compressTags = other.compressTags;
+ this.evictBlocksOnClose = other.evictBlocksOnClose;
+ this.inMemory = other.inMemory;
+ }
+
+ public TColumnFamilyDescriptor deepCopy() {
+ return new TColumnFamilyDescriptor(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ this.attributes = null;
+ this.configuration = null;
+ setBlockSizeIsSet(false);
+ this.blockSize = 0;
+ this.bloomnFilterType = null;
+ this.compressionType = null;
+ setDfsReplicationIsSet(false);
+ this.dfsReplication = 0;
+ this.dataBlockEncoding = null;
+ this.keepDeletedCells = null;
+ setMaxVersionsIsSet(false);
+ this.maxVersions = 0;
+ setMinVersionsIsSet(false);
+ this.minVersions = 0;
+ setScopeIsSet(false);
+ this.scope = 0;
+ setTimeToLiveIsSet(false);
+ this.timeToLive = 0;
+ setBlockCacheEnabledIsSet(false);
+ this.blockCacheEnabled = false;
+ setCacheBloomsOnWriteIsSet(false);
+ this.cacheBloomsOnWrite = false;
+ setCacheDataOnWriteIsSet(false);
+ this.cacheDataOnWrite = false;
+ setCacheIndexesOnWriteIsSet(false);
+ this.cacheIndexesOnWrite = false;
+ setCompressTagsIsSet(false);
+ this.compressTags = false;
+ setEvictBlocksOnCloseIsSet(false);
+ this.evictBlocksOnClose = false;
+ setInMemoryIsSet(false);
+ this.inMemory = false;
+ }
+
+ public byte[] getName() {
+ setName(org.apache.thrift.TBaseHelper.rightSize(name));
+ return name == null ? null : name.array();
+ }
+
+ public java.nio.ByteBuffer bufferForName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(name);
+ }
+
+ public TColumnFamilyDescriptor setName(byte[] name) {
+ this.name = name == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(name.clone());
+ return this;
+ }
+
+ public TColumnFamilyDescriptor setName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer name) {
+ this.name = org.apache.thrift.TBaseHelper.copyBinary(name);
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TColumnFamilyDescriptor setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ public int getConfigurationSize() {
+ return (this.configuration == null) ? 0 : this.configuration.size();
+ }
+
+ public void putToConfiguration(java.lang.String key, java.lang.String val) {
+ if (this.configuration == null) {
+ this.configuration = new java.util.HashMap<java.lang.String,java.lang.String>();
+ }
+ this.configuration.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.lang.String,java.lang.String> getConfiguration() {
+ return this.configuration;
+ }
+
+ public TColumnFamilyDescriptor setConfiguration(@org.apache.thrift.annotation.Nullable java.util.Map<java.lang.String,java.lang.String> configuration) {
+ this.configuration = configuration;
+ return this;
+ }
+
+ public void unsetConfiguration() {
+ this.configuration = null;
+ }
+
+ /** Returns true if field configuration is set (has been assigned a value) and false otherwise */
+ public boolean isSetConfiguration() {
+ return this.configuration != null;
+ }
+
+ public void setConfigurationIsSet(boolean value) {
+ if (!value) {
+ this.configuration = null;
+ }
+ }
+
+ public int getBlockSize() {
+ return this.blockSize;
+ }
+
+ public TColumnFamilyDescriptor setBlockSize(int blockSize) {
+ this.blockSize = blockSize;
+ setBlockSizeIsSet(true);
+ return this;
+ }
+
+ public void unsetBlockSize() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BLOCKSIZE_ISSET_ID);
+ }
+
+ /** Returns true if field blockSize is set (has been assigned a value) and false otherwise */
+ public boolean isSetBlockSize() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BLOCKSIZE_ISSET_ID);
+ }
+
+ public void setBlockSizeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BLOCKSIZE_ISSET_ID, value);
+ }
+
+ /**
+ *
+ * @see TBloomFilterType
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TBloomFilterType getBloomnFilterType() {
+ return this.bloomnFilterType;
+ }
+
+ /**
+ *
+ * @see TBloomFilterType
+ */
+ public TColumnFamilyDescriptor setBloomnFilterType(@org.apache.thrift.annotation.Nullable TBloomFilterType bloomnFilterType) {
+ this.bloomnFilterType = bloomnFilterType;
+ return this;
+ }
+
+ public void unsetBloomnFilterType() {
+ this.bloomnFilterType = null;
+ }
+
+ /** Returns true if field bloomnFilterType is set (has been assigned a value) and false otherwise */
+ public boolean isSetBloomnFilterType() {
+ return this.bloomnFilterType != null;
+ }
+
+ public void setBloomnFilterTypeIsSet(boolean value) {
+ if (!value) {
+ this.bloomnFilterType = null;
+ }
+ }
+
+ /**
+ *
+ * @see TCompressionAlgorithm
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TCompressionAlgorithm getCompressionType() {
+ return this.compressionType;
+ }
+
+ /**
+ *
+ * @see TCompressionAlgorithm
+ */
+ public TColumnFamilyDescriptor setCompressionType(@org.apache.thrift.annotation.Nullable TCompressionAlgorithm compressionType) {
+ this.compressionType = compressionType;
+ return this;
+ }
+
+ public void unsetCompressionType() {
+ this.compressionType = null;
+ }
+
+ /** Returns true if field compressionType is set (has been assigned a value) and false otherwise */
+ public boolean isSetCompressionType() {
+ return this.compressionType != null;
+ }
+
+ public void setCompressionTypeIsSet(boolean value) {
+ if (!value) {
+ this.compressionType = null;
+ }
+ }
+
+ public short getDfsReplication() {
+ return this.dfsReplication;
+ }
+
+ public TColumnFamilyDescriptor setDfsReplication(short dfsReplication) {
+ this.dfsReplication = dfsReplication;
+ setDfsReplicationIsSet(true);
+ return this;
+ }
+
+ public void unsetDfsReplication() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __DFSREPLICATION_ISSET_ID);
+ }
+
+ /** Returns true if field dfsReplication is set (has been assigned a value) and false otherwise */
+ public boolean isSetDfsReplication() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __DFSREPLICATION_ISSET_ID);
+ }
+
+ public void setDfsReplicationIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __DFSREPLICATION_ISSET_ID, value);
+ }
+
+ /**
+ *
+ * @see TDataBlockEncoding
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDataBlockEncoding getDataBlockEncoding() {
+ return this.dataBlockEncoding;
+ }
+
+ /**
+ *
+ * @see TDataBlockEncoding
+ */
+ public TColumnFamilyDescriptor setDataBlockEncoding(@org.apache.thrift.annotation.Nullable TDataBlockEncoding dataBlockEncoding) {
+ this.dataBlockEncoding = dataBlockEncoding;
+ return this;
+ }
+
+ public void unsetDataBlockEncoding() {
+ this.dataBlockEncoding = null;
+ }
+
+ /** Returns true if field dataBlockEncoding is set (has been assigned a value) and false otherwise */
+ public boolean isSetDataBlockEncoding() {
+ return this.dataBlockEncoding != null;
+ }
+
+ public void setDataBlockEncodingIsSet(boolean value) {
+ if (!value) {
+ this.dataBlockEncoding = null;
+ }
+ }
+
+ /**
+ *
+ * @see TKeepDeletedCells
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TKeepDeletedCells getKeepDeletedCells() {
+ return this.keepDeletedCells;
+ }
+
+ /**
+ *
+ * @see TKeepDeletedCells
+ */
+ public TColumnFamilyDescriptor setKeepDeletedCells(@org.apache.thrift.annotation.Nullable TKeepDeletedCells keepDeletedCells) {
+ this.keepDeletedCells = keepDeletedCells;
+ return this;
+ }
+
+ public void unsetKeepDeletedCells() {
+ this.keepDeletedCells = null;
+ }
+
+ /** Returns true if field keepDeletedCells is set (has been assigned a value) and false otherwise */
+ public boolean isSetKeepDeletedCells() {
+ return this.keepDeletedCells != null;
+ }
+
+ public void setKeepDeletedCellsIsSet(boolean value) {
+ if (!value) {
+ this.keepDeletedCells = null;
+ }
+ }
+
+ public int getMaxVersions() {
+ return this.maxVersions;
+ }
+
+ public TColumnFamilyDescriptor setMaxVersions(int maxVersions) {
+ this.maxVersions = maxVersions;
+ setMaxVersionsIsSet(true);
+ return this;
+ }
+
+ public void unsetMaxVersions() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ /** Returns true if field maxVersions is set (has been assigned a value) and false otherwise */
+ public boolean isSetMaxVersions() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ public void setMaxVersionsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID, value);
+ }
+
+ public int getMinVersions() {
+ return this.minVersions;
+ }
+
+ public TColumnFamilyDescriptor setMinVersions(int minVersions) {
+ this.minVersions = minVersions;
+ setMinVersionsIsSet(true);
+ return this;
+ }
+
+ public void unsetMinVersions() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MINVERSIONS_ISSET_ID);
+ }
+
+ /** Returns true if field minVersions is set (has been assigned a value) and false otherwise */
+ public boolean isSetMinVersions() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MINVERSIONS_ISSET_ID);
+ }
+
+ public void setMinVersionsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MINVERSIONS_ISSET_ID, value);
+ }
+
+ public int getScope() {
+ return this.scope;
+ }
+
+ public TColumnFamilyDescriptor setScope(int scope) {
+ this.scope = scope;
+ setScopeIsSet(true);
+ return this;
+ }
+
+ public void unsetScope() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SCOPE_ISSET_ID);
+ }
+
+ /** Returns true if field scope is set (has been assigned a value) and false otherwise */
+ public boolean isSetScope() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SCOPE_ISSET_ID);
+ }
+
+ public void setScopeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SCOPE_ISSET_ID, value);
+ }
+
+ public int getTimeToLive() {
+ return this.timeToLive;
+ }
+
+ public TColumnFamilyDescriptor setTimeToLive(int timeToLive) {
+ this.timeToLive = timeToLive;
+ setTimeToLiveIsSet(true);
+ return this;
+ }
+
+ public void unsetTimeToLive() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID);
+ }
+
+ /** Returns true if field timeToLive is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimeToLive() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID);
+ }
+
+ public void setTimeToLiveIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID, value);
+ }
+
+ public boolean isBlockCacheEnabled() {
+ return this.blockCacheEnabled;
+ }
+
+ public TColumnFamilyDescriptor setBlockCacheEnabled(boolean blockCacheEnabled) {
+ this.blockCacheEnabled = blockCacheEnabled;
+ setBlockCacheEnabledIsSet(true);
+ return this;
+ }
+
+ public void unsetBlockCacheEnabled() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID);
+ }
+
+ /** Returns true if field blockCacheEnabled is set (has been assigned a value) and false otherwise */
+ public boolean isSetBlockCacheEnabled() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID);
+ }
+
+ public void setBlockCacheEnabledIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID, value);
+ }
+
+ public boolean isCacheBloomsOnWrite() {
+ return this.cacheBloomsOnWrite;
+ }
+
+ public TColumnFamilyDescriptor setCacheBloomsOnWrite(boolean cacheBloomsOnWrite) {
+ this.cacheBloomsOnWrite = cacheBloomsOnWrite;
+ setCacheBloomsOnWriteIsSet(true);
+ return this;
+ }
+
+ public void unsetCacheBloomsOnWrite() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHEBLOOMSONWRITE_ISSET_ID);
+ }
+
+ /** Returns true if field cacheBloomsOnWrite is set (has been assigned a value) and false otherwise */
+ public boolean isSetCacheBloomsOnWrite() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHEBLOOMSONWRITE_ISSET_ID);
+ }
+
+ public void setCacheBloomsOnWriteIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHEBLOOMSONWRITE_ISSET_ID, value);
+ }
+
+ public boolean isCacheDataOnWrite() {
+ return this.cacheDataOnWrite;
+ }
+
+ public TColumnFamilyDescriptor setCacheDataOnWrite(boolean cacheDataOnWrite) {
+ this.cacheDataOnWrite = cacheDataOnWrite;
+ setCacheDataOnWriteIsSet(true);
+ return this;
+ }
+
+ public void unsetCacheDataOnWrite() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHEDATAONWRITE_ISSET_ID);
+ }
+
+ /** Returns true if field cacheDataOnWrite is set (has been assigned a value) and false otherwise */
+ public boolean isSetCacheDataOnWrite() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHEDATAONWRITE_ISSET_ID);
+ }
+
+ public void setCacheDataOnWriteIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHEDATAONWRITE_ISSET_ID, value);
+ }
+
+ public boolean isCacheIndexesOnWrite() {
+ return this.cacheIndexesOnWrite;
+ }
+
+ public TColumnFamilyDescriptor setCacheIndexesOnWrite(boolean cacheIndexesOnWrite) {
+ this.cacheIndexesOnWrite = cacheIndexesOnWrite;
+ setCacheIndexesOnWriteIsSet(true);
+ return this;
+ }
+
+ public void unsetCacheIndexesOnWrite() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHEINDEXESONWRITE_ISSET_ID);
+ }
+
+ /** Returns true if field cacheIndexesOnWrite is set (has been assigned a value) and false otherwise */
+ public boolean isSetCacheIndexesOnWrite() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHEINDEXESONWRITE_ISSET_ID);
+ }
+
+ public void setCacheIndexesOnWriteIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHEINDEXESONWRITE_ISSET_ID, value);
+ }
+
+ public boolean isCompressTags() {
+ return this.compressTags;
+ }
+
+ public TColumnFamilyDescriptor setCompressTags(boolean compressTags) {
+ this.compressTags = compressTags;
+ setCompressTagsIsSet(true);
+ return this;
+ }
+
+ public void unsetCompressTags() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __COMPRESSTAGS_ISSET_ID);
+ }
+
+ /** Returns true if field compressTags is set (has been assigned a value) and false otherwise */
+ public boolean isSetCompressTags() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __COMPRESSTAGS_ISSET_ID);
+ }
+
+ public void setCompressTagsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __COMPRESSTAGS_ISSET_ID, value);
+ }
+
+ public boolean isEvictBlocksOnClose() {
+ return this.evictBlocksOnClose;
+ }
+
+ public TColumnFamilyDescriptor setEvictBlocksOnClose(boolean evictBlocksOnClose) {
+ this.evictBlocksOnClose = evictBlocksOnClose;
+ setEvictBlocksOnCloseIsSet(true);
+ return this;
+ }
+
+ public void unsetEvictBlocksOnClose() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __EVICTBLOCKSONCLOSE_ISSET_ID);
+ }
+
+ /** Returns true if field evictBlocksOnClose is set (has been assigned a value) and false otherwise */
+ public boolean isSetEvictBlocksOnClose() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __EVICTBLOCKSONCLOSE_ISSET_ID);
+ }
+
+ public void setEvictBlocksOnCloseIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __EVICTBLOCKSONCLOSE_ISSET_ID, value);
+ }
+
+ public boolean isInMemory() {
+ return this.inMemory;
+ }
+
+ public TColumnFamilyDescriptor setInMemory(boolean inMemory) {
+ this.inMemory = inMemory;
+ setInMemoryIsSet(true);
+ return this;
+ }
+
+ public void unsetInMemory() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __INMEMORY_ISSET_ID);
+ }
+
+ /** Returns true if field inMemory is set (has been assigned a value) and false otherwise */
+ public boolean isSetInMemory() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __INMEMORY_ISSET_ID);
+ }
+
+ public void setInMemoryIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __INMEMORY_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ if (value instanceof byte[]) {
+ setName((byte[])value);
+ } else {
+ setName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case CONFIGURATION:
+ if (value == null) {
+ unsetConfiguration();
+ } else {
+ setConfiguration((java.util.Map<java.lang.String,java.lang.String>)value);
+ }
+ break;
+
+ case BLOCK_SIZE:
+ if (value == null) {
+ unsetBlockSize();
+ } else {
+ setBlockSize((java.lang.Integer)value);
+ }
+ break;
+
+ case BLOOMN_FILTER_TYPE:
+ if (value == null) {
+ unsetBloomnFilterType();
+ } else {
+ setBloomnFilterType((TBloomFilterType)value);
+ }
+ break;
+
+ case COMPRESSION_TYPE:
+ if (value == null) {
+ unsetCompressionType();
+ } else {
+ setCompressionType((TCompressionAlgorithm)value);
+ }
+ break;
+
+ case DFS_REPLICATION:
+ if (value == null) {
+ unsetDfsReplication();
+ } else {
+ setDfsReplication((java.lang.Short)value);
+ }
+ break;
+
+ case DATA_BLOCK_ENCODING:
+ if (value == null) {
+ unsetDataBlockEncoding();
+ } else {
+ setDataBlockEncoding((TDataBlockEncoding)value);
+ }
+ break;
+
+ case KEEP_DELETED_CELLS:
+ if (value == null) {
+ unsetKeepDeletedCells();
+ } else {
+ setKeepDeletedCells((TKeepDeletedCells)value);
+ }
+ break;
+
+ case MAX_VERSIONS:
+ if (value == null) {
+ unsetMaxVersions();
+ } else {
+ setMaxVersions((java.lang.Integer)value);
+ }
+ break;
+
+ case MIN_VERSIONS:
+ if (value == null) {
+ unsetMinVersions();
+ } else {
+ setMinVersions((java.lang.Integer)value);
+ }
+ break;
+
+ case SCOPE:
+ if (value == null) {
+ unsetScope();
+ } else {
+ setScope((java.lang.Integer)value);
+ }
+ break;
+
+ case TIME_TO_LIVE:
+ if (value == null) {
+ unsetTimeToLive();
+ } else {
+ setTimeToLive((java.lang.Integer)value);
+ }
+ break;
+
+ case BLOCK_CACHE_ENABLED:
+ if (value == null) {
+ unsetBlockCacheEnabled();
+ } else {
+ setBlockCacheEnabled((java.lang.Boolean)value);
+ }
+ break;
+
+ case CACHE_BLOOMS_ON_WRITE:
+ if (value == null) {
+ unsetCacheBloomsOnWrite();
+ } else {
+ setCacheBloomsOnWrite((java.lang.Boolean)value);
+ }
+ break;
+
+ case CACHE_DATA_ON_WRITE:
+ if (value == null) {
+ unsetCacheDataOnWrite();
+ } else {
+ setCacheDataOnWrite((java.lang.Boolean)value);
+ }
+ break;
+
+ case CACHE_INDEXES_ON_WRITE:
+ if (value == null) {
+ unsetCacheIndexesOnWrite();
+ } else {
+ setCacheIndexesOnWrite((java.lang.Boolean)value);
+ }
+ break;
+
+ case COMPRESS_TAGS:
+ if (value == null) {
+ unsetCompressTags();
+ } else {
+ setCompressTags((java.lang.Boolean)value);
+ }
+ break;
+
+ case EVICT_BLOCKS_ON_CLOSE:
+ if (value == null) {
+ unsetEvictBlocksOnClose();
+ } else {
+ setEvictBlocksOnClose((java.lang.Boolean)value);
+ }
+ break;
+
+ case IN_MEMORY:
+ if (value == null) {
+ unsetInMemory();
+ } else {
+ setInMemory((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case CONFIGURATION:
+ return getConfiguration();
+
+ case BLOCK_SIZE:
+ return getBlockSize();
+
+ case BLOOMN_FILTER_TYPE:
+ return getBloomnFilterType();
+
+ case COMPRESSION_TYPE:
+ return getCompressionType();
+
+ case DFS_REPLICATION:
+ return getDfsReplication();
+
+ case DATA_BLOCK_ENCODING:
+ return getDataBlockEncoding();
+
+ case KEEP_DELETED_CELLS:
+ return getKeepDeletedCells();
+
+ case MAX_VERSIONS:
+ return getMaxVersions();
+
+ case MIN_VERSIONS:
+ return getMinVersions();
+
+ case SCOPE:
+ return getScope();
+
+ case TIME_TO_LIVE:
+ return getTimeToLive();
+
+ case BLOCK_CACHE_ENABLED:
+ return isBlockCacheEnabled();
+
+ case CACHE_BLOOMS_ON_WRITE:
+ return isCacheBloomsOnWrite();
+
+ case CACHE_DATA_ON_WRITE:
+ return isCacheDataOnWrite();
+
+ case CACHE_INDEXES_ON_WRITE:
+ return isCacheIndexesOnWrite();
+
+ case COMPRESS_TAGS:
+ return isCompressTags();
+
+ case EVICT_BLOCKS_ON_CLOSE:
+ return isEvictBlocksOnClose();
+
+ case IN_MEMORY:
+ return isInMemory();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case CONFIGURATION:
+ return isSetConfiguration();
+ case BLOCK_SIZE:
+ return isSetBlockSize();
+ case BLOOMN_FILTER_TYPE:
+ return isSetBloomnFilterType();
+ case COMPRESSION_TYPE:
+ return isSetCompressionType();
+ case DFS_REPLICATION:
+ return isSetDfsReplication();
+ case DATA_BLOCK_ENCODING:
+ return isSetDataBlockEncoding();
+ case KEEP_DELETED_CELLS:
+ return isSetKeepDeletedCells();
+ case MAX_VERSIONS:
+ return isSetMaxVersions();
+ case MIN_VERSIONS:
+ return isSetMinVersions();
+ case SCOPE:
+ return isSetScope();
+ case TIME_TO_LIVE:
+ return isSetTimeToLive();
+ case BLOCK_CACHE_ENABLED:
+ return isSetBlockCacheEnabled();
+ case CACHE_BLOOMS_ON_WRITE:
+ return isSetCacheBloomsOnWrite();
+ case CACHE_DATA_ON_WRITE:
+ return isSetCacheDataOnWrite();
+ case CACHE_INDEXES_ON_WRITE:
+ return isSetCacheIndexesOnWrite();
+ case COMPRESS_TAGS:
+ return isSetCompressTags();
+ case EVICT_BLOCKS_ON_CLOSE:
+ return isSetEvictBlocksOnClose();
+ case IN_MEMORY:
+ return isSetInMemory();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TColumnFamilyDescriptor)
+ return this.equals((TColumnFamilyDescriptor)that);
+ return false;
+ }
+
+ public boolean equals(TColumnFamilyDescriptor that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_configuration = true && this.isSetConfiguration();
+ boolean that_present_configuration = true && that.isSetConfiguration();
+ if (this_present_configuration || that_present_configuration) {
+ if (!(this_present_configuration && that_present_configuration))
+ return false;
+ if (!this.configuration.equals(that.configuration))
+ return false;
+ }
+
+ boolean this_present_blockSize = true && this.isSetBlockSize();
+ boolean that_present_blockSize = true && that.isSetBlockSize();
+ if (this_present_blockSize || that_present_blockSize) {
+ if (!(this_present_blockSize && that_present_blockSize))
+ return false;
+ if (this.blockSize != that.blockSize)
+ return false;
+ }
+
+ boolean this_present_bloomnFilterType = true && this.isSetBloomnFilterType();
+ boolean that_present_bloomnFilterType = true && that.isSetBloomnFilterType();
+ if (this_present_bloomnFilterType || that_present_bloomnFilterType) {
+ if (!(this_present_bloomnFilterType && that_present_bloomnFilterType))
+ return false;
+ if (!this.bloomnFilterType.equals(that.bloomnFilterType))
+ return false;
+ }
+
+ boolean this_present_compressionType = true && this.isSetCompressionType();
+ boolean that_present_compressionType = true && that.isSetCompressionType();
+ if (this_present_compressionType || that_present_compressionType) {
+ if (!(this_present_compressionType && that_present_compressionType))
+ return false;
+ if (!this.compressionType.equals(that.compressionType))
+ return false;
+ }
+
+ boolean this_present_dfsReplication = true && this.isSetDfsReplication();
+ boolean that_present_dfsReplication = true && that.isSetDfsReplication();
+ if (this_present_dfsReplication || that_present_dfsReplication) {
+ if (!(this_present_dfsReplication && that_present_dfsReplication))
+ return false;
+ if (this.dfsReplication != that.dfsReplication)
+ return false;
+ }
+
+ boolean this_present_dataBlockEncoding = true && this.isSetDataBlockEncoding();
+ boolean that_present_dataBlockEncoding = true && that.isSetDataBlockEncoding();
+ if (this_present_dataBlockEncoding || that_present_dataBlockEncoding) {
+ if (!(this_present_dataBlockEncoding && that_present_dataBlockEncoding))
+ return false;
+ if (!this.dataBlockEncoding.equals(that.dataBlockEncoding))
+ return false;
+ }
+
+ boolean this_present_keepDeletedCells = true && this.isSetKeepDeletedCells();
+ boolean that_present_keepDeletedCells = true && that.isSetKeepDeletedCells();
+ if (this_present_keepDeletedCells || that_present_keepDeletedCells) {
+ if (!(this_present_keepDeletedCells && that_present_keepDeletedCells))
+ return false;
+ if (!this.keepDeletedCells.equals(that.keepDeletedCells))
+ return false;
+ }
+
+ boolean this_present_maxVersions = true && this.isSetMaxVersions();
+ boolean that_present_maxVersions = true && that.isSetMaxVersions();
+ if (this_present_maxVersions || that_present_maxVersions) {
+ if (!(this_present_maxVersions && that_present_maxVersions))
+ return false;
+ if (this.maxVersions != that.maxVersions)
+ return false;
+ }
+
+ boolean this_present_minVersions = true && this.isSetMinVersions();
+ boolean that_present_minVersions = true && that.isSetMinVersions();
+ if (this_present_minVersions || that_present_minVersions) {
+ if (!(this_present_minVersions && that_present_minVersions))
+ return false;
+ if (this.minVersions != that.minVersions)
+ return false;
+ }
+
+ boolean this_present_scope = true && this.isSetScope();
+ boolean that_present_scope = true && that.isSetScope();
+ if (this_present_scope || that_present_scope) {
+ if (!(this_present_scope && that_present_scope))
+ return false;
+ if (this.scope != that.scope)
+ return false;
+ }
+
+ boolean this_present_timeToLive = true && this.isSetTimeToLive();
+ boolean that_present_timeToLive = true && that.isSetTimeToLive();
+ if (this_present_timeToLive || that_present_timeToLive) {
+ if (!(this_present_timeToLive && that_present_timeToLive))
+ return false;
+ if (this.timeToLive != that.timeToLive)
+ return false;
+ }
+
+ boolean this_present_blockCacheEnabled = true && this.isSetBlockCacheEnabled();
+ boolean that_present_blockCacheEnabled = true && that.isSetBlockCacheEnabled();
+ if (this_present_blockCacheEnabled || that_present_blockCacheEnabled) {
+ if (!(this_present_blockCacheEnabled && that_present_blockCacheEnabled))
+ return false;
+ if (this.blockCacheEnabled != that.blockCacheEnabled)
+ return false;
+ }
+
+ boolean this_present_cacheBloomsOnWrite = true && this.isSetCacheBloomsOnWrite();
+ boolean that_present_cacheBloomsOnWrite = true && that.isSetCacheBloomsOnWrite();
+ if (this_present_cacheBloomsOnWrite || that_present_cacheBloomsOnWrite) {
+ if (!(this_present_cacheBloomsOnWrite && that_present_cacheBloomsOnWrite))
+ return false;
+ if (this.cacheBloomsOnWrite != that.cacheBloomsOnWrite)
+ return false;
+ }
+
+ boolean this_present_cacheDataOnWrite = true && this.isSetCacheDataOnWrite();
+ boolean that_present_cacheDataOnWrite = true && that.isSetCacheDataOnWrite();
+ if (this_present_cacheDataOnWrite || that_present_cacheDataOnWrite) {
+ if (!(this_present_cacheDataOnWrite && that_present_cacheDataOnWrite))
+ return false;
+ if (this.cacheDataOnWrite != that.cacheDataOnWrite)
+ return false;
+ }
+
+ boolean this_present_cacheIndexesOnWrite = true && this.isSetCacheIndexesOnWrite();
+ boolean that_present_cacheIndexesOnWrite = true && that.isSetCacheIndexesOnWrite();
+ if (this_present_cacheIndexesOnWrite || that_present_cacheIndexesOnWrite) {
+ if (!(this_present_cacheIndexesOnWrite && that_present_cacheIndexesOnWrite))
+ return false;
+ if (this.cacheIndexesOnWrite != that.cacheIndexesOnWrite)
+ return false;
+ }
+
+ boolean this_present_compressTags = true && this.isSetCompressTags();
+ boolean that_present_compressTags = true && that.isSetCompressTags();
+ if (this_present_compressTags || that_present_compressTags) {
+ if (!(this_present_compressTags && that_present_compressTags))
+ return false;
+ if (this.compressTags != that.compressTags)
+ return false;
+ }
+
+ boolean this_present_evictBlocksOnClose = true && this.isSetEvictBlocksOnClose();
+ boolean that_present_evictBlocksOnClose = true && that.isSetEvictBlocksOnClose();
+ if (this_present_evictBlocksOnClose || that_present_evictBlocksOnClose) {
+ if (!(this_present_evictBlocksOnClose && that_present_evictBlocksOnClose))
+ return false;
+ if (this.evictBlocksOnClose != that.evictBlocksOnClose)
+ return false;
+ }
+
+ boolean this_present_inMemory = true && this.isSetInMemory();
+ boolean that_present_inMemory = true && that.isSetInMemory();
+ if (this_present_inMemory || that_present_inMemory) {
+ if (!(this_present_inMemory && that_present_inMemory))
+ return false;
+ if (this.inMemory != that.inMemory)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetConfiguration()) ? 131071 : 524287);
+ if (isSetConfiguration())
+ hashCode = hashCode * 8191 + configuration.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetBlockSize()) ? 131071 : 524287);
+ if (isSetBlockSize())
+ hashCode = hashCode * 8191 + blockSize;
+
+ hashCode = hashCode * 8191 + ((isSetBloomnFilterType()) ? 131071 : 524287);
+ if (isSetBloomnFilterType())
+ hashCode = hashCode * 8191 + bloomnFilterType.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetCompressionType()) ? 131071 : 524287);
+ if (isSetCompressionType())
+ hashCode = hashCode * 8191 + compressionType.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetDfsReplication()) ? 131071 : 524287);
+ if (isSetDfsReplication())
+ hashCode = hashCode * 8191 + dfsReplication;
+
+ hashCode = hashCode * 8191 + ((isSetDataBlockEncoding()) ? 131071 : 524287);
+ if (isSetDataBlockEncoding())
+ hashCode = hashCode * 8191 + dataBlockEncoding.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetKeepDeletedCells()) ? 131071 : 524287);
+ if (isSetKeepDeletedCells())
+ hashCode = hashCode * 8191 + keepDeletedCells.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetMaxVersions()) ? 131071 : 524287);
+ if (isSetMaxVersions())
+ hashCode = hashCode * 8191 + maxVersions;
+
+ hashCode = hashCode * 8191 + ((isSetMinVersions()) ? 131071 : 524287);
+ if (isSetMinVersions())
+ hashCode = hashCode * 8191 + minVersions;
+
+ hashCode = hashCode * 8191 + ((isSetScope()) ? 131071 : 524287);
+ if (isSetScope())
+ hashCode = hashCode * 8191 + scope;
+
+ hashCode = hashCode * 8191 + ((isSetTimeToLive()) ? 131071 : 524287);
+ if (isSetTimeToLive())
+ hashCode = hashCode * 8191 + timeToLive;
+
+ hashCode = hashCode * 8191 + ((isSetBlockCacheEnabled()) ? 131071 : 524287);
+ if (isSetBlockCacheEnabled())
+ hashCode = hashCode * 8191 + ((blockCacheEnabled) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetCacheBloomsOnWrite()) ? 131071 : 524287);
+ if (isSetCacheBloomsOnWrite())
+ hashCode = hashCode * 8191 + ((cacheBloomsOnWrite) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetCacheDataOnWrite()) ? 131071 : 524287);
+ if (isSetCacheDataOnWrite())
+ hashCode = hashCode * 8191 + ((cacheDataOnWrite) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetCacheIndexesOnWrite()) ? 131071 : 524287);
+ if (isSetCacheIndexesOnWrite())
+ hashCode = hashCode * 8191 + ((cacheIndexesOnWrite) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetCompressTags()) ? 131071 : 524287);
+ if (isSetCompressTags())
+ hashCode = hashCode * 8191 + ((compressTags) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetEvictBlocksOnClose()) ? 131071 : 524287);
+ if (isSetEvictBlocksOnClose())
+ hashCode = hashCode * 8191 + ((evictBlocksOnClose) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetInMemory()) ? 131071 : 524287);
+ if (isSetInMemory())
+ hashCode = hashCode * 8191 + ((inMemory) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TColumnFamilyDescriptor other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetConfiguration(), other.isSetConfiguration());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetConfiguration()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.configuration, other.configuration);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBlockSize(), other.isSetBlockSize());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBlockSize()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.blockSize, other.blockSize);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBloomnFilterType(), other.isSetBloomnFilterType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBloomnFilterType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomnFilterType, other.bloomnFilterType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCompressionType(), other.isSetCompressionType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCompressionType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.compressionType, other.compressionType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDfsReplication(), other.isSetDfsReplication());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDfsReplication()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dfsReplication, other.dfsReplication);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDataBlockEncoding(), other.isSetDataBlockEncoding());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDataBlockEncoding()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataBlockEncoding, other.dataBlockEncoding);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetKeepDeletedCells(), other.isSetKeepDeletedCells());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetKeepDeletedCells()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.keepDeletedCells, other.keepDeletedCells);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMaxVersions(), other.isSetMaxVersions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMaxVersions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxVersions, other.maxVersions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMinVersions(), other.isSetMinVersions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMinVersions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.minVersions, other.minVersions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetScope(), other.isSetScope());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetScope()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scope, other.scope);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimeToLive(), other.isSetTimeToLive());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimeToLive()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeToLive, other.timeToLive);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBlockCacheEnabled(), other.isSetBlockCacheEnabled());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBlockCacheEnabled()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.blockCacheEnabled, other.blockCacheEnabled);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCacheBloomsOnWrite(), other.isSetCacheBloomsOnWrite());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCacheBloomsOnWrite()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheBloomsOnWrite, other.cacheBloomsOnWrite);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCacheDataOnWrite(), other.isSetCacheDataOnWrite());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCacheDataOnWrite()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheDataOnWrite, other.cacheDataOnWrite);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCacheIndexesOnWrite(), other.isSetCacheIndexesOnWrite());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCacheIndexesOnWrite()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheIndexesOnWrite, other.cacheIndexesOnWrite);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCompressTags(), other.isSetCompressTags());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCompressTags()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.compressTags, other.compressTags);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetEvictBlocksOnClose(), other.isSetEvictBlocksOnClose());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetEvictBlocksOnClose()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.evictBlocksOnClose, other.evictBlocksOnClose);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetInMemory(), other.isSetInMemory());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetInMemory()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.inMemory, other.inMemory);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TColumnFamilyDescriptor(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.name, sb);
+ }
+ first = false;
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetConfiguration()) {
+ if (!first) sb.append(", ");
+ sb.append("configuration:");
+ if (this.configuration == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.configuration);
+ }
+ first = false;
+ }
+ if (isSetBlockSize()) {
+ if (!first) sb.append(", ");
+ sb.append("blockSize:");
+ sb.append(this.blockSize);
+ first = false;
+ }
+ if (isSetBloomnFilterType()) {
+ if (!first) sb.append(", ");
+ sb.append("bloomnFilterType:");
+ if (this.bloomnFilterType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.bloomnFilterType);
+ }
+ first = false;
+ }
+ if (isSetCompressionType()) {
+ if (!first) sb.append(", ");
+ sb.append("compressionType:");
+ if (this.compressionType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.compressionType);
+ }
+ first = false;
+ }
+ if (isSetDfsReplication()) {
+ if (!first) sb.append(", ");
+ sb.append("dfsReplication:");
+ sb.append(this.dfsReplication);
+ first = false;
+ }
+ if (isSetDataBlockEncoding()) {
+ if (!first) sb.append(", ");
+ sb.append("dataBlockEncoding:");
+ if (this.dataBlockEncoding == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.dataBlockEncoding);
+ }
+ first = false;
+ }
+ if (isSetKeepDeletedCells()) {
+ if (!first) sb.append(", ");
+ sb.append("keepDeletedCells:");
+ if (this.keepDeletedCells == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.keepDeletedCells);
+ }
+ first = false;
+ }
+ if (isSetMaxVersions()) {
+ if (!first) sb.append(", ");
+ sb.append("maxVersions:");
+ sb.append(this.maxVersions);
+ first = false;
+ }
+ if (isSetMinVersions()) {
+ if (!first) sb.append(", ");
+ sb.append("minVersions:");
+ sb.append(this.minVersions);
+ first = false;
+ }
+ if (isSetScope()) {
+ if (!first) sb.append(", ");
+ sb.append("scope:");
+ sb.append(this.scope);
+ first = false;
+ }
+ if (isSetTimeToLive()) {
+ if (!first) sb.append(", ");
+ sb.append("timeToLive:");
+ sb.append(this.timeToLive);
+ first = false;
+ }
+ if (isSetBlockCacheEnabled()) {
+ if (!first) sb.append(", ");
+ sb.append("blockCacheEnabled:");
+ sb.append(this.blockCacheEnabled);
+ first = false;
+ }
+ if (isSetCacheBloomsOnWrite()) {
+ if (!first) sb.append(", ");
+ sb.append("cacheBloomsOnWrite:");
+ sb.append(this.cacheBloomsOnWrite);
+ first = false;
+ }
+ if (isSetCacheDataOnWrite()) {
+ if (!first) sb.append(", ");
+ sb.append("cacheDataOnWrite:");
+ sb.append(this.cacheDataOnWrite);
+ first = false;
+ }
+ if (isSetCacheIndexesOnWrite()) {
+ if (!first) sb.append(", ");
+ sb.append("cacheIndexesOnWrite:");
+ sb.append(this.cacheIndexesOnWrite);
+ first = false;
+ }
+ if (isSetCompressTags()) {
+ if (!first) sb.append(", ");
+ sb.append("compressTags:");
+ sb.append(this.compressTags);
+ first = false;
+ }
+ if (isSetEvictBlocksOnClose()) {
+ if (!first) sb.append(", ");
+ sb.append("evictBlocksOnClose:");
+ sb.append(this.evictBlocksOnClose);
+ first = false;
+ }
+ if (isSetInMemory()) {
+ if (!first) sb.append(", ");
+ sb.append("inMemory:");
+ sb.append(this.inMemory);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (name == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TColumnFamilyDescriptorStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnFamilyDescriptorStandardScheme getScheme() {
+ return new TColumnFamilyDescriptorStandardScheme();
+ }
+ }
+
+ private static class TColumnFamilyDescriptorStandardScheme extends org.apache.thrift.scheme.StandardScheme<TColumnFamilyDescriptor> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TColumnFamilyDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readBinary();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map142 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map142.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key143;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val144;
+ for (int _i145 = 0; _i145 < _map142.size; ++_i145)
+ {
+ _key143 = iprot.readBinary();
+ _val144 = iprot.readBinary();
+ struct.attributes.put(_key143, _val144);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // CONFIGURATION
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map146 = iprot.readMapBegin();
+ struct.configuration = new java.util.HashMap<java.lang.String,java.lang.String>(2*_map146.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _key147;
+ @org.apache.thrift.annotation.Nullable java.lang.String _val148;
+ for (int _i149 = 0; _i149 < _map146.size; ++_i149)
+ {
+ _key147 = iprot.readString();
+ _val148 = iprot.readString();
+ struct.configuration.put(_key147, _val148);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setConfigurationIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // BLOCK_SIZE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.blockSize = iprot.readI32();
+ struct.setBlockSizeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // BLOOMN_FILTER_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.bloomnFilterType = org.apache.hadoop.hbase.thrift2.generated.TBloomFilterType.findByValue(iprot.readI32());
+ struct.setBloomnFilterTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // COMPRESSION_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.compressionType = org.apache.hadoop.hbase.thrift2.generated.TCompressionAlgorithm.findByValue(iprot.readI32());
+ struct.setCompressionTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // DFS_REPLICATION
+ if (schemeField.type == org.apache.thrift.protocol.TType.I16) {
+ struct.dfsReplication = iprot.readI16();
+ struct.setDfsReplicationIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 8: // DATA_BLOCK_ENCODING
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.dataBlockEncoding = org.apache.hadoop.hbase.thrift2.generated.TDataBlockEncoding.findByValue(iprot.readI32());
+ struct.setDataBlockEncodingIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 9: // KEEP_DELETED_CELLS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.keepDeletedCells = org.apache.hadoop.hbase.thrift2.generated.TKeepDeletedCells.findByValue(iprot.readI32());
+ struct.setKeepDeletedCellsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 10: // MAX_VERSIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 11: // MIN_VERSIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.minVersions = iprot.readI32();
+ struct.setMinVersionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 12: // SCOPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.scope = iprot.readI32();
+ struct.setScopeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 13: // TIME_TO_LIVE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.timeToLive = iprot.readI32();
+ struct.setTimeToLiveIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 14: // BLOCK_CACHE_ENABLED
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.blockCacheEnabled = iprot.readBool();
+ struct.setBlockCacheEnabledIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 15: // CACHE_BLOOMS_ON_WRITE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.cacheBloomsOnWrite = iprot.readBool();
+ struct.setCacheBloomsOnWriteIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 16: // CACHE_DATA_ON_WRITE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.cacheDataOnWrite = iprot.readBool();
+ struct.setCacheDataOnWriteIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 17: // CACHE_INDEXES_ON_WRITE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.cacheIndexesOnWrite = iprot.readBool();
+ struct.setCacheIndexesOnWriteIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 18: // COMPRESS_TAGS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.compressTags = iprot.readBool();
+ struct.setCompressTagsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 19: // EVICT_BLOCKS_ON_CLOSE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.evictBlocksOnClose = iprot.readBool();
+ struct.setEvictBlocksOnCloseIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 20: // IN_MEMORY
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.inMemory = iprot.readBool();
+ struct.setInMemoryIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TColumnFamilyDescriptor struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeBinary(struct.name);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter150 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter150.getKey());
+ oprot.writeBinary(_iter150.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.configuration != null) {
+ if (struct.isSetConfiguration()) {
+ oprot.writeFieldBegin(CONFIGURATION_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.configuration.size()));
+ for (java.util.Map.Entry<java.lang.String, java.lang.String> _iter151 : struct.configuration.entrySet())
+ {
+ oprot.writeString(_iter151.getKey());
+ oprot.writeString(_iter151.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetBlockSize()) {
+ oprot.writeFieldBegin(BLOCK_SIZE_FIELD_DESC);
+ oprot.writeI32(struct.blockSize);
+ oprot.writeFieldEnd();
+ }
+ if (struct.bloomnFilterType != null) {
+ if (struct.isSetBloomnFilterType()) {
+ oprot.writeFieldBegin(BLOOMN_FILTER_TYPE_FIELD_DESC);
+ oprot.writeI32(struct.bloomnFilterType.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.compressionType != null) {
+ if (struct.isSetCompressionType()) {
+ oprot.writeFieldBegin(COMPRESSION_TYPE_FIELD_DESC);
+ oprot.writeI32(struct.compressionType.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetDfsReplication()) {
+ oprot.writeFieldBegin(DFS_REPLICATION_FIELD_DESC);
+ oprot.writeI16(struct.dfsReplication);
+ oprot.writeFieldEnd();
+ }
+ if (struct.dataBlockEncoding != null) {
+ if (struct.isSetDataBlockEncoding()) {
+ oprot.writeFieldBegin(DATA_BLOCK_ENCODING_FIELD_DESC);
+ oprot.writeI32(struct.dataBlockEncoding.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.keepDeletedCells != null) {
+ if (struct.isSetKeepDeletedCells()) {
+ oprot.writeFieldBegin(KEEP_DELETED_CELLS_FIELD_DESC);
+ oprot.writeI32(struct.keepDeletedCells.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetMaxVersions()) {
+ oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
+ oprot.writeI32(struct.maxVersions);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetMinVersions()) {
+ oprot.writeFieldBegin(MIN_VERSIONS_FIELD_DESC);
+ oprot.writeI32(struct.minVersions);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetScope()) {
+ oprot.writeFieldBegin(SCOPE_FIELD_DESC);
+ oprot.writeI32(struct.scope);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetTimeToLive()) {
+ oprot.writeFieldBegin(TIME_TO_LIVE_FIELD_DESC);
+ oprot.writeI32(struct.timeToLive);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetBlockCacheEnabled()) {
+ oprot.writeFieldBegin(BLOCK_CACHE_ENABLED_FIELD_DESC);
+ oprot.writeBool(struct.blockCacheEnabled);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetCacheBloomsOnWrite()) {
+ oprot.writeFieldBegin(CACHE_BLOOMS_ON_WRITE_FIELD_DESC);
+ oprot.writeBool(struct.cacheBloomsOnWrite);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetCacheDataOnWrite()) {
+ oprot.writeFieldBegin(CACHE_DATA_ON_WRITE_FIELD_DESC);
+ oprot.writeBool(struct.cacheDataOnWrite);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetCacheIndexesOnWrite()) {
+ oprot.writeFieldBegin(CACHE_INDEXES_ON_WRITE_FIELD_DESC);
+ oprot.writeBool(struct.cacheIndexesOnWrite);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetCompressTags()) {
+ oprot.writeFieldBegin(COMPRESS_TAGS_FIELD_DESC);
+ oprot.writeBool(struct.compressTags);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetEvictBlocksOnClose()) {
+ oprot.writeFieldBegin(EVICT_BLOCKS_ON_CLOSE_FIELD_DESC);
+ oprot.writeBool(struct.evictBlocksOnClose);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetInMemory()) {
+ oprot.writeFieldBegin(IN_MEMORY_FIELD_DESC);
+ oprot.writeBool(struct.inMemory);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TColumnFamilyDescriptorTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnFamilyDescriptorTupleScheme getScheme() {
+ return new TColumnFamilyDescriptorTupleScheme();
+ }
+ }
+
+ private static class TColumnFamilyDescriptorTupleScheme extends org.apache.thrift.scheme.TupleScheme<TColumnFamilyDescriptor> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TColumnFamilyDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.name);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetAttributes()) {
+ optionals.set(0);
+ }
+ if (struct.isSetConfiguration()) {
+ optionals.set(1);
+ }
+ if (struct.isSetBlockSize()) {
+ optionals.set(2);
+ }
+ if (struct.isSetBloomnFilterType()) {
+ optionals.set(3);
+ }
+ if (struct.isSetCompressionType()) {
+ optionals.set(4);
+ }
+ if (struct.isSetDfsReplication()) {
+ optionals.set(5);
+ }
+ if (struct.isSetDataBlockEncoding()) {
+ optionals.set(6);
+ }
+ if (struct.isSetKeepDeletedCells()) {
+ optionals.set(7);
+ }
+ if (struct.isSetMaxVersions()) {
+ optionals.set(8);
+ }
+ if (struct.isSetMinVersions()) {
+ optionals.set(9);
+ }
+ if (struct.isSetScope()) {
+ optionals.set(10);
+ }
+ if (struct.isSetTimeToLive()) {
+ optionals.set(11);
+ }
+ if (struct.isSetBlockCacheEnabled()) {
+ optionals.set(12);
+ }
+ if (struct.isSetCacheBloomsOnWrite()) {
+ optionals.set(13);
+ }
+ if (struct.isSetCacheDataOnWrite()) {
+ optionals.set(14);
+ }
+ if (struct.isSetCacheIndexesOnWrite()) {
+ optionals.set(15);
+ }
+ if (struct.isSetCompressTags()) {
+ optionals.set(16);
+ }
+ if (struct.isSetEvictBlocksOnClose()) {
+ optionals.set(17);
+ }
+ if (struct.isSetInMemory()) {
+ optionals.set(18);
+ }
+ oprot.writeBitSet(optionals, 19);
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter152 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter152.getKey());
+ oprot.writeBinary(_iter152.getValue());
+ }
+ }
+ }
+ if (struct.isSetConfiguration()) {
+ {
+ oprot.writeI32(struct.configuration.size());
+ for (java.util.Map.Entry<java.lang.String, java.lang.String> _iter153 : struct.configuration.entrySet())
+ {
+ oprot.writeString(_iter153.getKey());
+ oprot.writeString(_iter153.getValue());
+ }
+ }
+ }
+ if (struct.isSetBlockSize()) {
+ oprot.writeI32(struct.blockSize);
+ }
+ if (struct.isSetBloomnFilterType()) {
+ oprot.writeI32(struct.bloomnFilterType.getValue());
+ }
+ if (struct.isSetCompressionType()) {
+ oprot.writeI32(struct.compressionType.getValue());
+ }
+ if (struct.isSetDfsReplication()) {
+ oprot.writeI16(struct.dfsReplication);
+ }
+ if (struct.isSetDataBlockEncoding()) {
+ oprot.writeI32(struct.dataBlockEncoding.getValue());
+ }
+ if (struct.isSetKeepDeletedCells()) {
+ oprot.writeI32(struct.keepDeletedCells.getValue());
+ }
+ if (struct.isSetMaxVersions()) {
+ oprot.writeI32(struct.maxVersions);
+ }
+ if (struct.isSetMinVersions()) {
+ oprot.writeI32(struct.minVersions);
+ }
+ if (struct.isSetScope()) {
+ oprot.writeI32(struct.scope);
+ }
+ if (struct.isSetTimeToLive()) {
+ oprot.writeI32(struct.timeToLive);
+ }
+ if (struct.isSetBlockCacheEnabled()) {
+ oprot.writeBool(struct.blockCacheEnabled);
+ }
+ if (struct.isSetCacheBloomsOnWrite()) {
+ oprot.writeBool(struct.cacheBloomsOnWrite);
+ }
+ if (struct.isSetCacheDataOnWrite()) {
+ oprot.writeBool(struct.cacheDataOnWrite);
+ }
+ if (struct.isSetCacheIndexesOnWrite()) {
+ oprot.writeBool(struct.cacheIndexesOnWrite);
+ }
+ if (struct.isSetCompressTags()) {
+ oprot.writeBool(struct.compressTags);
+ }
+ if (struct.isSetEvictBlocksOnClose()) {
+ oprot.writeBool(struct.evictBlocksOnClose);
+ }
+ if (struct.isSetInMemory()) {
+ oprot.writeBool(struct.inMemory);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TColumnFamilyDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.name = iprot.readBinary();
+ struct.setNameIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(19);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TMap _map154 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map154.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key155;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val156;
+ for (int _i157 = 0; _i157 < _map154.size; ++_i157)
+ {
+ _key155 = iprot.readBinary();
+ _val156 = iprot.readBinary();
+ struct.attributes.put(_key155, _val156);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TMap _map158 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.configuration = new java.util.HashMap<java.lang.String,java.lang.String>(2*_map158.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _key159;
+ @org.apache.thrift.annotation.Nullable java.lang.String _val160;
+ for (int _i161 = 0; _i161 < _map158.size; ++_i161)
+ {
+ _key159 = iprot.readString();
+ _val160 = iprot.readString();
+ struct.configuration.put(_key159, _val160);
+ }
+ }
+ struct.setConfigurationIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.blockSize = iprot.readI32();
+ struct.setBlockSizeIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.bloomnFilterType = org.apache.hadoop.hbase.thrift2.generated.TBloomFilterType.findByValue(iprot.readI32());
+ struct.setBloomnFilterTypeIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.compressionType = org.apache.hadoop.hbase.thrift2.generated.TCompressionAlgorithm.findByValue(iprot.readI32());
+ struct.setCompressionTypeIsSet(true);
+ }
+ if (incoming.get(5)) {
+ struct.dfsReplication = iprot.readI16();
+ struct.setDfsReplicationIsSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.dataBlockEncoding = org.apache.hadoop.hbase.thrift2.generated.TDataBlockEncoding.findByValue(iprot.readI32());
+ struct.setDataBlockEncodingIsSet(true);
+ }
+ if (incoming.get(7)) {
+ struct.keepDeletedCells = org.apache.hadoop.hbase.thrift2.generated.TKeepDeletedCells.findByValue(iprot.readI32());
+ struct.setKeepDeletedCellsIsSet(true);
+ }
+ if (incoming.get(8)) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ }
+ if (incoming.get(9)) {
+ struct.minVersions = iprot.readI32();
+ struct.setMinVersionsIsSet(true);
+ }
+ if (incoming.get(10)) {
+ struct.scope = iprot.readI32();
+ struct.setScopeIsSet(true);
+ }
+ if (incoming.get(11)) {
+ struct.timeToLive = iprot.readI32();
+ struct.setTimeToLiveIsSet(true);
+ }
+ if (incoming.get(12)) {
+ struct.blockCacheEnabled = iprot.readBool();
+ struct.setBlockCacheEnabledIsSet(true);
+ }
+ if (incoming.get(13)) {
+ struct.cacheBloomsOnWrite = iprot.readBool();
+ struct.setCacheBloomsOnWriteIsSet(true);
+ }
+ if (incoming.get(14)) {
+ struct.cacheDataOnWrite = iprot.readBool();
+ struct.setCacheDataOnWriteIsSet(true);
+ }
+ if (incoming.get(15)) {
+ struct.cacheIndexesOnWrite = iprot.readBool();
+ struct.setCacheIndexesOnWriteIsSet(true);
+ }
+ if (incoming.get(16)) {
+ struct.compressTags = iprot.readBool();
+ struct.setCompressTagsIsSet(true);
+ }
+ if (incoming.get(17)) {
+ struct.evictBlocksOnClose = iprot.readBool();
+ struct.setEvictBlocksOnCloseIsSet(true);
+ }
+ if (incoming.get(18)) {
+ struct.inMemory = iprot.readBool();
+ struct.setInMemoryIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnIncrement.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnIncrement.java
new file mode 100644
index 0000000..2fb514d
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnIncrement.java
@@ -0,0 +1,607 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Represents a single cell and the amount to increment it by
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TColumnIncrement implements org.apache.thrift.TBase<TColumnIncrement, TColumnIncrement._Fields>, java.io.Serializable, Cloneable, Comparable<TColumnIncrement> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumnIncrement");
+
+ private static final org.apache.thrift.protocol.TField FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)2);
+ private static final org.apache.thrift.protocol.TField AMOUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("amount", org.apache.thrift.protocol.TType.I64, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TColumnIncrementStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TColumnIncrementTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier; // required
+ public long amount; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ FAMILY((short)1, "family"),
+ QUALIFIER((short)2, "qualifier"),
+ AMOUNT((short)3, "amount");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // FAMILY
+ return FAMILY;
+ case 2: // QUALIFIER
+ return QUALIFIER;
+ case 3: // AMOUNT
+ return AMOUNT;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __AMOUNT_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.AMOUNT};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.AMOUNT, new org.apache.thrift.meta_data.FieldMetaData("amount", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TColumnIncrement.class, metaDataMap);
+ }
+
+ public TColumnIncrement() {
+ this.amount = 1L;
+
+ }
+
+ public TColumnIncrement(
+ java.nio.ByteBuffer family,
+ java.nio.ByteBuffer qualifier)
+ {
+ this();
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TColumnIncrement(TColumnIncrement other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetFamily()) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
+ }
+ if (other.isSetQualifier()) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
+ }
+ this.amount = other.amount;
+ }
+
+ public TColumnIncrement deepCopy() {
+ return new TColumnIncrement(this);
+ }
+
+ @Override
+ public void clear() {
+ this.family = null;
+ this.qualifier = null;
+ this.amount = 1L;
+
+ }
+
+ public byte[] getFamily() {
+ setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
+ return family == null ? null : family.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFamily() {
+ return org.apache.thrift.TBaseHelper.copyBinary(family);
+ }
+
+ public TColumnIncrement setFamily(byte[] family) {
+ this.family = family == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(family.clone());
+ return this;
+ }
+
+ public TColumnIncrement setFamily(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ return this;
+ }
+
+ public void unsetFamily() {
+ this.family = null;
+ }
+
+ /** Returns true if field family is set (has been assigned a value) and false otherwise */
+ public boolean isSetFamily() {
+ return this.family != null;
+ }
+
+ public void setFamilyIsSet(boolean value) {
+ if (!value) {
+ this.family = null;
+ }
+ }
+
+ public byte[] getQualifier() {
+ setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
+ return qualifier == null ? null : qualifier.array();
+ }
+
+ public java.nio.ByteBuffer bufferForQualifier() {
+ return org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ public TColumnIncrement setQualifier(byte[] qualifier) {
+ this.qualifier = qualifier == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(qualifier.clone());
+ return this;
+ }
+
+ public TColumnIncrement setQualifier(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ return this;
+ }
+
+ public void unsetQualifier() {
+ this.qualifier = null;
+ }
+
+ /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
+ public boolean isSetQualifier() {
+ return this.qualifier != null;
+ }
+
+ public void setQualifierIsSet(boolean value) {
+ if (!value) {
+ this.qualifier = null;
+ }
+ }
+
+ public long getAmount() {
+ return this.amount;
+ }
+
+ public TColumnIncrement setAmount(long amount) {
+ this.amount = amount;
+ setAmountIsSet(true);
+ return this;
+ }
+
+ public void unsetAmount() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __AMOUNT_ISSET_ID);
+ }
+
+ /** Returns true if field amount is set (has been assigned a value) and false otherwise */
+ public boolean isSetAmount() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __AMOUNT_ISSET_ID);
+ }
+
+ public void setAmountIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __AMOUNT_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case FAMILY:
+ if (value == null) {
+ unsetFamily();
+ } else {
+ if (value instanceof byte[]) {
+ setFamily((byte[])value);
+ } else {
+ setFamily((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case QUALIFIER:
+ if (value == null) {
+ unsetQualifier();
+ } else {
+ if (value instanceof byte[]) {
+ setQualifier((byte[])value);
+ } else {
+ setQualifier((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case AMOUNT:
+ if (value == null) {
+ unsetAmount();
+ } else {
+ setAmount((java.lang.Long)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case FAMILY:
+ return getFamily();
+
+ case QUALIFIER:
+ return getQualifier();
+
+ case AMOUNT:
+ return getAmount();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case FAMILY:
+ return isSetFamily();
+ case QUALIFIER:
+ return isSetQualifier();
+ case AMOUNT:
+ return isSetAmount();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TColumnIncrement)
+ return this.equals((TColumnIncrement)that);
+ return false;
+ }
+
+ public boolean equals(TColumnIncrement that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_family = true && this.isSetFamily();
+ boolean that_present_family = true && that.isSetFamily();
+ if (this_present_family || that_present_family) {
+ if (!(this_present_family && that_present_family))
+ return false;
+ if (!this.family.equals(that.family))
+ return false;
+ }
+
+ boolean this_present_qualifier = true && this.isSetQualifier();
+ boolean that_present_qualifier = true && that.isSetQualifier();
+ if (this_present_qualifier || that_present_qualifier) {
+ if (!(this_present_qualifier && that_present_qualifier))
+ return false;
+ if (!this.qualifier.equals(that.qualifier))
+ return false;
+ }
+
+ boolean this_present_amount = true && this.isSetAmount();
+ boolean that_present_amount = true && that.isSetAmount();
+ if (this_present_amount || that_present_amount) {
+ if (!(this_present_amount && that_present_amount))
+ return false;
+ if (this.amount != that.amount)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetFamily()) ? 131071 : 524287);
+ if (isSetFamily())
+ hashCode = hashCode * 8191 + family.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetQualifier()) ? 131071 : 524287);
+ if (isSetQualifier())
+ hashCode = hashCode * 8191 + qualifier.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAmount()) ? 131071 : 524287);
+ if (isSetAmount())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(amount);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TColumnIncrement other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetFamily(), other.isSetFamily());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFamily()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, other.family);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQualifier(), other.isSetQualifier());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQualifier()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, other.qualifier);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAmount(), other.isSetAmount());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAmount()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.amount, other.amount);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TColumnIncrement(");
+ boolean first = true;
+
+ sb.append("family:");
+ if (this.family == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.family, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("qualifier:");
+ if (this.qualifier == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
+ }
+ first = false;
+ if (isSetAmount()) {
+ if (!first) sb.append(", ");
+ sb.append("amount:");
+ sb.append(this.amount);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (family == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
+ }
+ if (qualifier == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TColumnIncrementStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnIncrementStandardScheme getScheme() {
+ return new TColumnIncrementStandardScheme();
+ }
+ }
+
+ private static class TColumnIncrementStandardScheme extends org.apache.thrift.scheme.StandardScheme<TColumnIncrement> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TColumnIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // FAMILY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // QUALIFIER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // AMOUNT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.amount = iprot.readI64();
+ struct.setAmountIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TColumnIncrement struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.family != null) {
+ oprot.writeFieldBegin(FAMILY_FIELD_DESC);
+ oprot.writeBinary(struct.family);
+ oprot.writeFieldEnd();
+ }
+ if (struct.qualifier != null) {
+ oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetAmount()) {
+ oprot.writeFieldBegin(AMOUNT_FIELD_DESC);
+ oprot.writeI64(struct.amount);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TColumnIncrementTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnIncrementTupleScheme getScheme() {
+ return new TColumnIncrementTupleScheme();
+ }
+ }
+
+ private static class TColumnIncrementTupleScheme extends org.apache.thrift.scheme.TupleScheme<TColumnIncrement> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TColumnIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.family);
+ oprot.writeBinary(struct.qualifier);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetAmount()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetAmount()) {
+ oprot.writeI64(struct.amount);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TColumnIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.amount = iprot.readI64();
+ struct.setAmountIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnValue.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnValue.java
new file mode 100644
index 0000000..a30487a
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnValue.java
@@ -0,0 +1,938 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Represents a single cell and its value.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TColumnValue implements org.apache.thrift.TBase<TColumnValue, TColumnValue._Fields>, java.io.Serializable, Cloneable, Comparable<TColumnValue> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumnValue");
+
+ private static final org.apache.thrift.protocol.TField FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)2);
+ private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", 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 TAGS_FIELD_DESC = new org.apache.thrift.protocol.TField("tags", org.apache.thrift.protocol.TType.STRING, (short)5);
+ private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.BYTE, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TColumnValueStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TColumnValueTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value; // required
+ public long timestamp; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tags; // optional
+ public byte type; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ FAMILY((short)1, "family"),
+ QUALIFIER((short)2, "qualifier"),
+ VALUE((short)3, "value"),
+ TIMESTAMP((short)4, "timestamp"),
+ TAGS((short)5, "tags"),
+ TYPE((short)6, "type");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // FAMILY
+ return FAMILY;
+ case 2: // QUALIFIER
+ return QUALIFIER;
+ case 3: // VALUE
+ return VALUE;
+ case 4: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // TAGS
+ return TAGS;
+ case 6: // TYPE
+ return TYPE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private static final int __TYPE_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.TIMESTAMP,_Fields.TAGS,_Fields.TYPE};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ 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.TAGS, new org.apache.thrift.meta_data.FieldMetaData("tags", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TColumnValue.class, metaDataMap);
+ }
+
+ public TColumnValue() {
+ }
+
+ public TColumnValue(
+ java.nio.ByteBuffer family,
+ java.nio.ByteBuffer qualifier,
+ java.nio.ByteBuffer value)
+ {
+ this();
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TColumnValue(TColumnValue other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetFamily()) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
+ }
+ if (other.isSetQualifier()) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
+ }
+ if (other.isSetValue()) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetTags()) {
+ this.tags = org.apache.thrift.TBaseHelper.copyBinary(other.tags);
+ }
+ this.type = other.type;
+ }
+
+ public TColumnValue deepCopy() {
+ return new TColumnValue(this);
+ }
+
+ @Override
+ public void clear() {
+ this.family = null;
+ this.qualifier = null;
+ this.value = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.tags = null;
+ setTypeIsSet(false);
+ this.type = 0;
+ }
+
+ public byte[] getFamily() {
+ setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
+ return family == null ? null : family.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFamily() {
+ return org.apache.thrift.TBaseHelper.copyBinary(family);
+ }
+
+ public TColumnValue setFamily(byte[] family) {
+ this.family = family == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(family.clone());
+ return this;
+ }
+
+ public TColumnValue setFamily(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ return this;
+ }
+
+ public void unsetFamily() {
+ this.family = null;
+ }
+
+ /** Returns true if field family is set (has been assigned a value) and false otherwise */
+ public boolean isSetFamily() {
+ return this.family != null;
+ }
+
+ public void setFamilyIsSet(boolean value) {
+ if (!value) {
+ this.family = null;
+ }
+ }
+
+ public byte[] getQualifier() {
+ setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
+ return qualifier == null ? null : qualifier.array();
+ }
+
+ public java.nio.ByteBuffer bufferForQualifier() {
+ return org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ public TColumnValue setQualifier(byte[] qualifier) {
+ this.qualifier = qualifier == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(qualifier.clone());
+ return this;
+ }
+
+ public TColumnValue setQualifier(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ return this;
+ }
+
+ public void unsetQualifier() {
+ this.qualifier = null;
+ }
+
+ /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
+ public boolean isSetQualifier() {
+ return this.qualifier != null;
+ }
+
+ public void setQualifierIsSet(boolean value) {
+ if (!value) {
+ this.qualifier = null;
+ }
+ }
+
+ public byte[] getValue() {
+ setValue(org.apache.thrift.TBaseHelper.rightSize(value));
+ return value == null ? null : value.array();
+ }
+
+ public java.nio.ByteBuffer bufferForValue() {
+ return org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ public TColumnValue setValue(byte[] value) {
+ this.value = value == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(value.clone());
+ return this;
+ }
+
+ public TColumnValue setValue(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ return this;
+ }
+
+ public void unsetValue() {
+ this.value = null;
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return this.value != null;
+ }
+
+ public void setValueIsSet(boolean value) {
+ if (!value) {
+ this.value = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public TColumnValue setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public byte[] getTags() {
+ setTags(org.apache.thrift.TBaseHelper.rightSize(tags));
+ return tags == null ? null : tags.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTags() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tags);
+ }
+
+ public TColumnValue setTags(byte[] tags) {
+ this.tags = tags == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tags.clone());
+ return this;
+ }
+
+ public TColumnValue setTags(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tags) {
+ this.tags = org.apache.thrift.TBaseHelper.copyBinary(tags);
+ return this;
+ }
+
+ public void unsetTags() {
+ this.tags = null;
+ }
+
+ /** Returns true if field tags is set (has been assigned a value) and false otherwise */
+ public boolean isSetTags() {
+ return this.tags != null;
+ }
+
+ public void setTagsIsSet(boolean value) {
+ if (!value) {
+ this.tags = null;
+ }
+ }
+
+ public byte getType() {
+ return this.type;
+ }
+
+ public TColumnValue setType(byte type) {
+ this.type = type;
+ setTypeIsSet(true);
+ return this;
+ }
+
+ public void unsetType() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TYPE_ISSET_ID);
+ }
+
+ /** Returns true if field type is set (has been assigned a value) and false otherwise */
+ public boolean isSetType() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TYPE_ISSET_ID);
+ }
+
+ public void setTypeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TYPE_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case FAMILY:
+ if (value == null) {
+ unsetFamily();
+ } else {
+ if (value instanceof byte[]) {
+ setFamily((byte[])value);
+ } else {
+ setFamily((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case QUALIFIER:
+ if (value == null) {
+ unsetQualifier();
+ } else {
+ if (value instanceof byte[]) {
+ setQualifier((byte[])value);
+ } else {
+ setQualifier((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ if (value instanceof byte[]) {
+ setValue((byte[])value);
+ } else {
+ setValue((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case TAGS:
+ if (value == null) {
+ unsetTags();
+ } else {
+ if (value instanceof byte[]) {
+ setTags((byte[])value);
+ } else {
+ setTags((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TYPE:
+ if (value == null) {
+ unsetType();
+ } else {
+ setType((java.lang.Byte)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case FAMILY:
+ return getFamily();
+
+ case QUALIFIER:
+ return getQualifier();
+
+ case VALUE:
+ return getValue();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case TAGS:
+ return getTags();
+
+ case TYPE:
+ return getType();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case FAMILY:
+ return isSetFamily();
+ case QUALIFIER:
+ return isSetQualifier();
+ case VALUE:
+ return isSetValue();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case TAGS:
+ return isSetTags();
+ case TYPE:
+ return isSetType();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TColumnValue)
+ return this.equals((TColumnValue)that);
+ return false;
+ }
+
+ public boolean equals(TColumnValue that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_family = true && this.isSetFamily();
+ boolean that_present_family = true && that.isSetFamily();
+ if (this_present_family || that_present_family) {
+ if (!(this_present_family && that_present_family))
+ return false;
+ if (!this.family.equals(that.family))
+ return false;
+ }
+
+ boolean this_present_qualifier = true && this.isSetQualifier();
+ boolean that_present_qualifier = true && that.isSetQualifier();
+ if (this_present_qualifier || that_present_qualifier) {
+ if (!(this_present_qualifier && that_present_qualifier))
+ return false;
+ if (!this.qualifier.equals(that.qualifier))
+ return false;
+ }
+
+ boolean this_present_value = true && this.isSetValue();
+ boolean that_present_value = true && that.isSetValue();
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (!this.value.equals(that.value))
+ return false;
+ }
+
+ boolean this_present_timestamp = true && this.isSetTimestamp();
+ boolean that_present_timestamp = true && that.isSetTimestamp();
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_tags = true && this.isSetTags();
+ boolean that_present_tags = true && that.isSetTags();
+ if (this_present_tags || that_present_tags) {
+ if (!(this_present_tags && that_present_tags))
+ return false;
+ if (!this.tags.equals(that.tags))
+ return false;
+ }
+
+ boolean this_present_type = true && this.isSetType();
+ boolean that_present_type = true && that.isSetType();
+ if (this_present_type || that_present_type) {
+ if (!(this_present_type && that_present_type))
+ return false;
+ if (this.type != that.type)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetFamily()) ? 131071 : 524287);
+ if (isSetFamily())
+ hashCode = hashCode * 8191 + family.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetQualifier()) ? 131071 : 524287);
+ if (isSetQualifier())
+ hashCode = hashCode * 8191 + qualifier.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetValue()) ? 131071 : 524287);
+ if (isSetValue())
+ hashCode = hashCode * 8191 + value.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTimestamp()) ? 131071 : 524287);
+ if (isSetTimestamp())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetTags()) ? 131071 : 524287);
+ if (isSetTags())
+ hashCode = hashCode * 8191 + tags.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetType()) ? 131071 : 524287);
+ if (isSetType())
+ hashCode = hashCode * 8191 + (int) (type);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TColumnValue other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetFamily(), other.isSetFamily());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFamily()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, other.family);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQualifier(), other.isSetQualifier());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQualifier()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, other.qualifier);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTags(), other.isSetTags());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTags()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tags, other.tags);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetType(), other.isSetType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TColumnValue(");
+ boolean first = true;
+
+ sb.append("family:");
+ if (this.family == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.family, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("qualifier:");
+ if (this.qualifier == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("value:");
+ if (this.value == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.value, sb);
+ }
+ first = false;
+ if (isSetTimestamp()) {
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ }
+ if (isSetTags()) {
+ if (!first) sb.append(", ");
+ sb.append("tags:");
+ if (this.tags == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tags, sb);
+ }
+ first = false;
+ }
+ if (isSetType()) {
+ if (!first) sb.append(", ");
+ sb.append("type:");
+ sb.append(this.type);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (family == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
+ }
+ if (qualifier == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
+ }
+ if (value == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'value' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TColumnValueStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnValueStandardScheme getScheme() {
+ return new TColumnValueStandardScheme();
+ }
+ }
+
+ private static class TColumnValueStandardScheme extends org.apache.thrift.scheme.StandardScheme<TColumnValue> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TColumnValue struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // FAMILY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // QUALIFIER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // TAGS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tags = iprot.readBinary();
+ struct.setTagsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BYTE) {
+ struct.type = iprot.readByte();
+ struct.setTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TColumnValue struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.family != null) {
+ oprot.writeFieldBegin(FAMILY_FIELD_DESC);
+ oprot.writeBinary(struct.family);
+ oprot.writeFieldEnd();
+ }
+ if (struct.qualifier != null) {
+ oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeFieldEnd();
+ }
+ if (struct.value != null) {
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeBinary(struct.value);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tags != null) {
+ if (struct.isSetTags()) {
+ oprot.writeFieldBegin(TAGS_FIELD_DESC);
+ oprot.writeBinary(struct.tags);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetType()) {
+ oprot.writeFieldBegin(TYPE_FIELD_DESC);
+ oprot.writeByte(struct.type);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TColumnValueTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TColumnValueTupleScheme getScheme() {
+ return new TColumnValueTupleScheme();
+ }
+ }
+
+ private static class TColumnValueTupleScheme extends org.apache.thrift.scheme.TupleScheme<TColumnValue> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TColumnValue struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.family);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeBinary(struct.value);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTimestamp()) {
+ optionals.set(0);
+ }
+ if (struct.isSetTags()) {
+ optionals.set(1);
+ }
+ if (struct.isSetType()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetTags()) {
+ oprot.writeBinary(struct.tags);
+ }
+ if (struct.isSetType()) {
+ oprot.writeByte(struct.type);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TColumnValue struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.tags = iprot.readBinary();
+ struct.setTagsIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.type = iprot.readByte();
+ struct.setTypeIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompareOperator.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompareOperator.java
new file mode 100644
index 0000000..6c749d5
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompareOperator.java
@@ -0,0 +1,62 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.CompareOperator.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TCompareOperator implements org.apache.thrift.TEnum {
+ LESS(0),
+ LESS_OR_EQUAL(1),
+ EQUAL(2),
+ NOT_EQUAL(3),
+ GREATER_OR_EQUAL(4),
+ GREATER(5),
+ NO_OP(6);
+
+ private final int value;
+
+ private TCompareOperator(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TCompareOperator findByValue(int value) {
+ switch (value) {
+ case 0:
+ return LESS;
+ case 1:
+ return LESS_OR_EQUAL;
+ case 2:
+ return EQUAL;
+ case 3:
+ return NOT_EQUAL;
+ case 4:
+ return GREATER_OR_EQUAL;
+ case 5:
+ return GREATER;
+ case 6:
+ return NO_OP;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompressionAlgorithm.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompressionAlgorithm.java
new file mode 100644
index 0000000..e4deb10
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompressionAlgorithm.java
@@ -0,0 +1,62 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.io.compress.Algorithm
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TCompressionAlgorithm implements org.apache.thrift.TEnum {
+ LZO(0),
+ GZ(1),
+ NONE(2),
+ SNAPPY(3),
+ LZ4(4),
+ BZIP2(5),
+ ZSTD(6);
+
+ private final int value;
+
+ private TCompressionAlgorithm(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TCompressionAlgorithm findByValue(int value) {
+ switch (value) {
+ case 0:
+ return LZO;
+ case 1:
+ return GZ;
+ case 2:
+ return NONE;
+ case 3:
+ return SNAPPY;
+ case 4:
+ return LZ4;
+ case 5:
+ return BZIP2;
+ case 6:
+ return ZSTD;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TConsistency.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TConsistency.java
new file mode 100644
index 0000000..17b6d2b
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TConsistency.java
@@ -0,0 +1,48 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Specify Consistency:
+ * - STRONG means reads only from primary region
+ * - TIMELINE means reads might return values from secondary region replicas
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TConsistency implements org.apache.thrift.TEnum {
+ STRONG(1),
+ TIMELINE(2);
+
+ private final int value;
+
+ private TConsistency(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TConsistency findByValue(int value) {
+ switch (value) {
+ case 1:
+ return STRONG;
+ case 2:
+ return TIMELINE;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDataBlockEncoding.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDataBlockEncoding.java
new file mode 100644
index 0000000..c3c7429
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDataBlockEncoding.java
@@ -0,0 +1,59 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.io.encoding.DataBlockEncoding
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TDataBlockEncoding implements org.apache.thrift.TEnum {
+ /**
+ * Disable data block encoding.
+ */
+ NONE(0),
+ PREFIX(2),
+ DIFF(3),
+ FAST_DIFF(4),
+ ROW_INDEX_V1(7);
+
+ private final int value;
+
+ private TDataBlockEncoding(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TDataBlockEncoding findByValue(int value) {
+ switch (value) {
+ case 0:
+ return NONE;
+ case 2:
+ return PREFIX;
+ case 3:
+ return DIFF;
+ case 4:
+ return FAST_DIFF;
+ case 7:
+ return ROW_INDEX_V1;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDelete.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDelete.java
new file mode 100644
index 0000000..bb217d1
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDelete.java
@@ -0,0 +1,1084 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Used to perform Delete operations on a single row.
+ *
+ * The scope can be further narrowed down by specifying a list of
+ * columns or column families as TColumns.
+ *
+ * Specifying only a family in a TColumn will delete the whole family.
+ * If a timestamp is specified all versions with a timestamp less than
+ * or equal to this will be deleted. If no timestamp is specified the
+ * current time will be used.
+ *
+ * Specifying a family and a column qualifier in a TColumn will delete only
+ * this qualifier. If a timestamp is specified only versions equal
+ * to this timestamp will be deleted. If no timestamp is specified the
+ * most recent version will be deleted. To delete all previous versions,
+ * specify the DELETE_COLUMNS TDeleteType.
+ *
+ * The top level timestamp is only used if a complete row should be deleted
+ * (i.e. no columns are passed) and if it is specified it works the same way
+ * as if you had added a TColumn for every column family and this timestamp
+ * (i.e. all versions older than or equal in all column families will be deleted)
+ *
+ * You can specify how this Delete should be written to the write-ahead Log (WAL)
+ * by changing the durability. If you don't provide durability, it defaults to
+ * column family's default setting for durability.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TDelete implements org.apache.thrift.TBase<TDelete, TDelete._Fields>, java.io.Serializable, Cloneable, Comparable<TDelete> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TDelete");
+
+ 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)1);
+ 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)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 DELETE_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteType", org.apache.thrift.protocol.TType.I32, (short)4);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)6);
+ private static final org.apache.thrift.protocol.TField DURABILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("durability", org.apache.thrift.protocol.TType.I32, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TDeleteStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TDeleteTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns; // optional
+ public long timestamp; // optional
+ /**
+ *
+ * @see TDeleteType
+ */
+ public @org.apache.thrift.annotation.Nullable TDeleteType deleteType; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ /**
+ *
+ * @see TDurability
+ */
+ public @org.apache.thrift.annotation.Nullable TDurability durability; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ COLUMNS((short)2, "columns"),
+ TIMESTAMP((short)3, "timestamp"),
+ /**
+ *
+ * @see TDeleteType
+ */
+ DELETE_TYPE((short)4, "deleteType"),
+ ATTRIBUTES((short)6, "attributes"),
+ /**
+ *
+ * @see TDurability
+ */
+ DURABILITY((short)7, "durability");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // COLUMNS
+ return COLUMNS;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 4: // DELETE_TYPE
+ return DELETE_TYPE;
+ case 6: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 7: // DURABILITY
+ return DURABILITY;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.COLUMNS,_Fields.TIMESTAMP,_Fields.DELETE_TYPE,_Fields.ATTRIBUTES,_Fields.DURABILITY};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumn.class))));
+ 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.DELETE_TYPE, new org.apache.thrift.meta_data.FieldMetaData("deleteType", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDeleteType.class)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.DURABILITY, new org.apache.thrift.meta_data.FieldMetaData("durability", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDurability.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TDelete.class, metaDataMap);
+ }
+
+ public TDelete() {
+ this.deleteType = org.apache.hadoop.hbase.thrift2.generated.TDeleteType.DELETE_COLUMNS;
+
+ }
+
+ public TDelete(
+ java.nio.ByteBuffer row)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TDelete(TDelete other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<TColumn> __this__columns = new java.util.ArrayList<TColumn>(other.columns.size());
+ for (TColumn other_element : other.columns) {
+ __this__columns.add(new TColumn(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetDeleteType()) {
+ this.deleteType = other.deleteType;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetDurability()) {
+ this.durability = other.durability;
+ }
+ }
+
+ public TDelete deepCopy() {
+ return new TDelete(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.columns = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.deleteType = org.apache.hadoop.hbase.thrift2.generated.TDeleteType.DELETE_COLUMNS;
+
+ this.attributes = null;
+ this.durability = null;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TDelete setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TDelete setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumn> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(TColumn elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<TColumn>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumn> getColumns() {
+ return this.columns;
+ }
+
+ public TDelete setColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public TDelete setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ /**
+ *
+ * @see TDeleteType
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDeleteType getDeleteType() {
+ return this.deleteType;
+ }
+
+ /**
+ *
+ * @see TDeleteType
+ */
+ public TDelete setDeleteType(@org.apache.thrift.annotation.Nullable TDeleteType deleteType) {
+ this.deleteType = deleteType;
+ return this;
+ }
+
+ public void unsetDeleteType() {
+ this.deleteType = null;
+ }
+
+ /** Returns true if field deleteType is set (has been assigned a value) and false otherwise */
+ public boolean isSetDeleteType() {
+ return this.deleteType != null;
+ }
+
+ public void setDeleteTypeIsSet(boolean value) {
+ if (!value) {
+ this.deleteType = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TDelete setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDurability getDurability() {
+ return this.durability;
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ public TDelete setDurability(@org.apache.thrift.annotation.Nullable TDurability durability) {
+ this.durability = durability;
+ return this;
+ }
+
+ public void unsetDurability() {
+ this.durability = null;
+ }
+
+ /** Returns true if field durability is set (has been assigned a value) and false otherwise */
+ public boolean isSetDurability() {
+ return this.durability != null;
+ }
+
+ public void setDurabilityIsSet(boolean value) {
+ if (!value) {
+ this.durability = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<TColumn>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case DELETE_TYPE:
+ if (value == null) {
+ unsetDeleteType();
+ } else {
+ setDeleteType((TDeleteType)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case DURABILITY:
+ if (value == null) {
+ unsetDurability();
+ } else {
+ setDurability((TDurability)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case DELETE_TYPE:
+ return getDeleteType();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case DURABILITY:
+ return getDurability();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case DELETE_TYPE:
+ return isSetDeleteType();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case DURABILITY:
+ return isSetDurability();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TDelete)
+ return this.equals((TDelete)that);
+ return false;
+ }
+
+ public boolean equals(TDelete that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_timestamp = true && this.isSetTimestamp();
+ boolean that_present_timestamp = true && that.isSetTimestamp();
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_deleteType = true && this.isSetDeleteType();
+ boolean that_present_deleteType = true && that.isSetDeleteType();
+ if (this_present_deleteType || that_present_deleteType) {
+ if (!(this_present_deleteType && that_present_deleteType))
+ return false;
+ if (!this.deleteType.equals(that.deleteType))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_durability = true && this.isSetDurability();
+ boolean that_present_durability = true && that.isSetDurability();
+ if (this_present_durability || that_present_durability) {
+ if (!(this_present_durability && that_present_durability))
+ return false;
+ if (!this.durability.equals(that.durability))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTimestamp()) ? 131071 : 524287);
+ if (isSetTimestamp())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetDeleteType()) ? 131071 : 524287);
+ if (isSetDeleteType())
+ hashCode = hashCode * 8191 + deleteType.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetDurability()) ? 131071 : 524287);
+ if (isSetDurability())
+ hashCode = hashCode * 8191 + durability.getValue();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TDelete other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDeleteType(), other.isSetDeleteType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDeleteType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteType, other.deleteType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDurability(), other.isSetDurability());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDurability()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.durability, other.durability);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TDelete(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (isSetColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columns);
+ }
+ first = false;
+ }
+ if (isSetTimestamp()) {
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ }
+ if (isSetDeleteType()) {
+ if (!first) sb.append(", ");
+ sb.append("deleteType:");
+ if (this.deleteType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.deleteType);
+ }
+ first = false;
+ }
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetDurability()) {
+ if (!first) sb.append(", ");
+ sb.append("durability:");
+ if (this.durability == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.durability);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TDeleteStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TDeleteStandardScheme getScheme() {
+ return new TDeleteStandardScheme();
+ }
+ }
+
+ private static class TDeleteStandardScheme extends org.apache.thrift.scheme.StandardScheme<TDelete> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TDelete struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<TColumn>(_list52.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem53;
+ for (int _i54 = 0; _i54 < _list52.size; ++_i54)
+ {
+ _elem53 = new TColumn();
+ _elem53.read(iprot);
+ struct.columns.add(_elem53);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // DELETE_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.deleteType = org.apache.hadoop.hbase.thrift2.generated.TDeleteType.findByValue(iprot.readI32());
+ struct.setDeleteTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map55 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map55.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key56;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val57;
+ for (int _i58 = 0; _i58 < _map55.size; ++_i58)
+ {
+ _key56 = iprot.readBinary();
+ _val57 = iprot.readBinary();
+ struct.attributes.put(_key56, _val57);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // DURABILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TDelete struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ if (struct.isSetColumns()) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+ for (TColumn _iter59 : struct.columns)
+ {
+ _iter59.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ }
+ if (struct.deleteType != null) {
+ if (struct.isSetDeleteType()) {
+ oprot.writeFieldBegin(DELETE_TYPE_FIELD_DESC);
+ oprot.writeI32(struct.deleteType.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter60 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter60.getKey());
+ oprot.writeBinary(_iter60.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.durability != null) {
+ if (struct.isSetDurability()) {
+ oprot.writeFieldBegin(DURABILITY_FIELD_DESC);
+ oprot.writeI32(struct.durability.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TDeleteTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TDeleteTupleScheme getScheme() {
+ return new TDeleteTupleScheme();
+ }
+ }
+
+ private static class TDeleteTupleScheme extends org.apache.thrift.scheme.TupleScheme<TDelete> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TDelete struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.row);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetColumns()) {
+ optionals.set(0);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(1);
+ }
+ if (struct.isSetDeleteType()) {
+ optionals.set(2);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(3);
+ }
+ if (struct.isSetDurability()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (TColumn _iter61 : struct.columns)
+ {
+ _iter61.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetDeleteType()) {
+ oprot.writeI32(struct.deleteType.getValue());
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter62 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter62.getKey());
+ oprot.writeBinary(_iter62.getValue());
+ }
+ }
+ }
+ if (struct.isSetDurability()) {
+ oprot.writeI32(struct.durability.getValue());
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TDelete struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list63 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columns = new java.util.ArrayList<TColumn>(_list63.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem64;
+ for (int _i65 = 0; _i65 < _list63.size; ++_i65)
+ {
+ _elem64 = new TColumn();
+ _elem64.read(iprot);
+ struct.columns.add(_elem64);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.deleteType = org.apache.hadoop.hbase.thrift2.generated.TDeleteType.findByValue(iprot.readI32());
+ struct.setDeleteTypeIsSet(true);
+ }
+ if (incoming.get(3)) {
+ {
+ org.apache.thrift.protocol.TMap _map66 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map66.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key67;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val68;
+ for (int _i69 = 0; _i69 < _map66.size; ++_i69)
+ {
+ _key67 = iprot.readBinary();
+ _val68 = iprot.readBinary();
+ struct.attributes.put(_key67, _val68);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDeleteType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDeleteType.java
new file mode 100644
index 0000000..3ccf01e
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDeleteType.java
@@ -0,0 +1,54 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Specify type of delete:
+ * - DELETE_COLUMN means exactly one version will be removed,
+ * - DELETE_COLUMNS means previous versions will also be removed.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TDeleteType implements org.apache.thrift.TEnum {
+ DELETE_COLUMN(0),
+ DELETE_COLUMNS(1),
+ DELETE_FAMILY(2),
+ DELETE_FAMILY_VERSION(3);
+
+ private final int value;
+
+ private TDeleteType(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TDeleteType findByValue(int value) {
+ switch (value) {
+ case 0:
+ return DELETE_COLUMN;
+ case 1:
+ return DELETE_COLUMNS;
+ case 2:
+ return DELETE_FAMILY;
+ case 3:
+ return DELETE_FAMILY_VERSION;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDurability.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDurability.java
new file mode 100644
index 0000000..638d440
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDurability.java
@@ -0,0 +1,59 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Specify Durability:
+ * - SKIP_WAL means do not write the Mutation to the WAL.
+ * - ASYNC_WAL means write the Mutation to the WAL asynchronously,
+ * - SYNC_WAL means write the Mutation to the WAL synchronously,
+ * - FSYNC_WAL means Write the Mutation to the WAL synchronously and force the entries to disk.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TDurability implements org.apache.thrift.TEnum {
+ USE_DEFAULT(0),
+ SKIP_WAL(1),
+ ASYNC_WAL(2),
+ SYNC_WAL(3),
+ FSYNC_WAL(4);
+
+ private final int value;
+
+ private TDurability(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TDurability findByValue(int value) {
+ switch (value) {
+ case 0:
+ return USE_DEFAULT;
+ case 1:
+ return SKIP_WAL;
+ case 2:
+ return ASYNC_WAL;
+ case 3:
+ return SYNC_WAL;
+ case 4:
+ return FSYNC_WAL;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TFilterByOperator.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TFilterByOperator.java
new file mode 100644
index 0000000..61ee2f6
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TFilterByOperator.java
@@ -0,0 +1,43 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TFilterByOperator implements org.apache.thrift.TEnum {
+ AND(0),
+ OR(1);
+
+ private final int value;
+
+ private TFilterByOperator(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TFilterByOperator findByValue(int value) {
+ switch (value) {
+ case 0:
+ return AND;
+ case 1:
+ return OR;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TGet.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TGet.java
new file mode 100644
index 0000000..dfecde9
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TGet.java
@@ -0,0 +1,2003 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Used to perform Get operations on a single row.
+ *
+ * The scope can be further narrowed down by specifying a list of
+ * columns or column families.
+ *
+ * To get everything for a row, instantiate a Get object with just the row to get.
+ * To further define the scope of what to get you can add a timestamp or time range
+ * with an optional maximum number of versions to return.
+ *
+ * If you specify a time range and a timestamp the range is ignored.
+ * Timestamps on TColumns are ignored.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TGet implements org.apache.thrift.TBase<TGet, TGet._Fields>, java.io.Serializable, Cloneable, Comparable<TGet> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TGet");
+
+ 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)1);
+ 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)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 TIME_RANGE_FIELD_DESC = new org.apache.thrift.protocol.TField("timeRange", org.apache.thrift.protocol.TType.STRUCT, (short)4);
+ private static final org.apache.thrift.protocol.TField MAX_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("maxVersions", org.apache.thrift.protocol.TType.I32, (short)5);
+ private static final org.apache.thrift.protocol.TField FILTER_STRING_FIELD_DESC = new org.apache.thrift.protocol.TField("filterString", org.apache.thrift.protocol.TType.STRING, (short)6);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)7);
+ private static final org.apache.thrift.protocol.TField AUTHORIZATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("authorizations", org.apache.thrift.protocol.TType.STRUCT, (short)8);
+ private static final org.apache.thrift.protocol.TField CONSISTENCY_FIELD_DESC = new org.apache.thrift.protocol.TField("consistency", org.apache.thrift.protocol.TType.I32, (short)9);
+ private static final org.apache.thrift.protocol.TField TARGET_REPLICA_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("targetReplicaId", org.apache.thrift.protocol.TType.I32, (short)10);
+ private static final org.apache.thrift.protocol.TField CACHE_BLOCKS_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheBlocks", org.apache.thrift.protocol.TType.BOOL, (short)11);
+ private static final org.apache.thrift.protocol.TField STORE_LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("storeLimit", org.apache.thrift.protocol.TType.I32, (short)12);
+ private static final org.apache.thrift.protocol.TField STORE_OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("storeOffset", org.apache.thrift.protocol.TType.I32, (short)13);
+ private static final org.apache.thrift.protocol.TField EXISTENCE_ONLY_FIELD_DESC = new org.apache.thrift.protocol.TField("existence_only", org.apache.thrift.protocol.TType.BOOL, (short)14);
+ private static final org.apache.thrift.protocol.TField FILTER_BYTES_FIELD_DESC = new org.apache.thrift.protocol.TField("filterBytes", org.apache.thrift.protocol.TType.STRING, (short)15);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TGetStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TGetTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns; // optional
+ public long timestamp; // optional
+ public @org.apache.thrift.annotation.Nullable TTimeRange timeRange; // optional
+ public int maxVersions; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ public @org.apache.thrift.annotation.Nullable TAuthorization authorizations; // optional
+ /**
+ *
+ * @see TConsistency
+ */
+ public @org.apache.thrift.annotation.Nullable TConsistency consistency; // optional
+ public int targetReplicaId; // optional
+ public boolean cacheBlocks; // optional
+ public int storeLimit; // optional
+ public int storeOffset; // optional
+ public boolean existence_only; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterBytes; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ COLUMNS((short)2, "columns"),
+ TIMESTAMP((short)3, "timestamp"),
+ TIME_RANGE((short)4, "timeRange"),
+ MAX_VERSIONS((short)5, "maxVersions"),
+ FILTER_STRING((short)6, "filterString"),
+ ATTRIBUTES((short)7, "attributes"),
+ AUTHORIZATIONS((short)8, "authorizations"),
+ /**
+ *
+ * @see TConsistency
+ */
+ CONSISTENCY((short)9, "consistency"),
+ TARGET_REPLICA_ID((short)10, "targetReplicaId"),
+ CACHE_BLOCKS((short)11, "cacheBlocks"),
+ STORE_LIMIT((short)12, "storeLimit"),
+ STORE_OFFSET((short)13, "storeOffset"),
+ EXISTENCE_ONLY((short)14, "existence_only"),
+ FILTER_BYTES((short)15, "filterBytes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // COLUMNS
+ return COLUMNS;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 4: // TIME_RANGE
+ return TIME_RANGE;
+ case 5: // MAX_VERSIONS
+ return MAX_VERSIONS;
+ case 6: // FILTER_STRING
+ return FILTER_STRING;
+ case 7: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 8: // AUTHORIZATIONS
+ return AUTHORIZATIONS;
+ case 9: // CONSISTENCY
+ return CONSISTENCY;
+ case 10: // TARGET_REPLICA_ID
+ return TARGET_REPLICA_ID;
+ case 11: // CACHE_BLOCKS
+ return CACHE_BLOCKS;
+ case 12: // STORE_LIMIT
+ return STORE_LIMIT;
+ case 13: // STORE_OFFSET
+ return STORE_OFFSET;
+ case 14: // EXISTENCE_ONLY
+ return EXISTENCE_ONLY;
+ case 15: // FILTER_BYTES
+ return FILTER_BYTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private static final int __MAXVERSIONS_ISSET_ID = 1;
+ private static final int __TARGETREPLICAID_ISSET_ID = 2;
+ private static final int __CACHEBLOCKS_ISSET_ID = 3;
+ private static final int __STORELIMIT_ISSET_ID = 4;
+ private static final int __STOREOFFSET_ISSET_ID = 5;
+ private static final int __EXISTENCE_ONLY_ISSET_ID = 6;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.COLUMNS,_Fields.TIMESTAMP,_Fields.TIME_RANGE,_Fields.MAX_VERSIONS,_Fields.FILTER_STRING,_Fields.ATTRIBUTES,_Fields.AUTHORIZATIONS,_Fields.CONSISTENCY,_Fields.TARGET_REPLICA_ID,_Fields.CACHE_BLOCKS,_Fields.STORE_LIMIT,_Fields.STORE_OFFSET,_Fields.EXISTENCE_ONLY,_Fields.FILTER_BYTES};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumn.class))));
+ 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.TIME_RANGE, new org.apache.thrift.meta_data.FieldMetaData("timeRange", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTimeRange.class)));
+ tmpMap.put(_Fields.MAX_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("maxVersions", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.FILTER_STRING, new org.apache.thrift.meta_data.FieldMetaData("filterString", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.AUTHORIZATIONS, new org.apache.thrift.meta_data.FieldMetaData("authorizations", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAuthorization.class)));
+ tmpMap.put(_Fields.CONSISTENCY, new org.apache.thrift.meta_data.FieldMetaData("consistency", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TConsistency.class)));
+ tmpMap.put(_Fields.TARGET_REPLICA_ID, new org.apache.thrift.meta_data.FieldMetaData("targetReplicaId", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.CACHE_BLOCKS, new org.apache.thrift.meta_data.FieldMetaData("cacheBlocks", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.STORE_LIMIT, new org.apache.thrift.meta_data.FieldMetaData("storeLimit", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.STORE_OFFSET, new org.apache.thrift.meta_data.FieldMetaData("storeOffset", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.EXISTENCE_ONLY, new org.apache.thrift.meta_data.FieldMetaData("existence_only", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.FILTER_BYTES, new org.apache.thrift.meta_data.FieldMetaData("filterBytes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TGet.class, metaDataMap);
+ }
+
+ public TGet() {
+ }
+
+ public TGet(
+ java.nio.ByteBuffer row)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TGet(TGet other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<TColumn> __this__columns = new java.util.ArrayList<TColumn>(other.columns.size());
+ for (TColumn other_element : other.columns) {
+ __this__columns.add(new TColumn(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetTimeRange()) {
+ this.timeRange = new TTimeRange(other.timeRange);
+ }
+ this.maxVersions = other.maxVersions;
+ if (other.isSetFilterString()) {
+ this.filterString = org.apache.thrift.TBaseHelper.copyBinary(other.filterString);
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetAuthorizations()) {
+ this.authorizations = new TAuthorization(other.authorizations);
+ }
+ if (other.isSetConsistency()) {
+ this.consistency = other.consistency;
+ }
+ this.targetReplicaId = other.targetReplicaId;
+ this.cacheBlocks = other.cacheBlocks;
+ this.storeLimit = other.storeLimit;
+ this.storeOffset = other.storeOffset;
+ this.existence_only = other.existence_only;
+ if (other.isSetFilterBytes()) {
+ this.filterBytes = org.apache.thrift.TBaseHelper.copyBinary(other.filterBytes);
+ }
+ }
+
+ public TGet deepCopy() {
+ return new TGet(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.columns = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.timeRange = null;
+ setMaxVersionsIsSet(false);
+ this.maxVersions = 0;
+ this.filterString = null;
+ this.attributes = null;
+ this.authorizations = null;
+ this.consistency = null;
+ setTargetReplicaIdIsSet(false);
+ this.targetReplicaId = 0;
+ setCacheBlocksIsSet(false);
+ this.cacheBlocks = false;
+ setStoreLimitIsSet(false);
+ this.storeLimit = 0;
+ setStoreOffsetIsSet(false);
+ this.storeOffset = 0;
+ setExistence_onlyIsSet(false);
+ this.existence_only = false;
+ this.filterBytes = null;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TGet setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TGet setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumn> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(TColumn elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<TColumn>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumn> getColumns() {
+ return this.columns;
+ }
+
+ public TGet setColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public TGet setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TTimeRange getTimeRange() {
+ return this.timeRange;
+ }
+
+ public TGet setTimeRange(@org.apache.thrift.annotation.Nullable TTimeRange timeRange) {
+ this.timeRange = timeRange;
+ return this;
+ }
+
+ public void unsetTimeRange() {
+ this.timeRange = null;
+ }
+
+ /** Returns true if field timeRange is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimeRange() {
+ return this.timeRange != null;
+ }
+
+ public void setTimeRangeIsSet(boolean value) {
+ if (!value) {
+ this.timeRange = null;
+ }
+ }
+
+ public int getMaxVersions() {
+ return this.maxVersions;
+ }
+
+ public TGet setMaxVersions(int maxVersions) {
+ this.maxVersions = maxVersions;
+ setMaxVersionsIsSet(true);
+ return this;
+ }
+
+ public void unsetMaxVersions() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ /** Returns true if field maxVersions is set (has been assigned a value) and false otherwise */
+ public boolean isSetMaxVersions() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ public void setMaxVersionsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID, value);
+ }
+
+ public byte[] getFilterString() {
+ setFilterString(org.apache.thrift.TBaseHelper.rightSize(filterString));
+ return filterString == null ? null : filterString.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFilterString() {
+ return org.apache.thrift.TBaseHelper.copyBinary(filterString);
+ }
+
+ public TGet setFilterString(byte[] filterString) {
+ this.filterString = filterString == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(filterString.clone());
+ return this;
+ }
+
+ public TGet setFilterString(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString) {
+ this.filterString = org.apache.thrift.TBaseHelper.copyBinary(filterString);
+ return this;
+ }
+
+ public void unsetFilterString() {
+ this.filterString = null;
+ }
+
+ /** Returns true if field filterString is set (has been assigned a value) and false otherwise */
+ public boolean isSetFilterString() {
+ return this.filterString != null;
+ }
+
+ public void setFilterStringIsSet(boolean value) {
+ if (!value) {
+ this.filterString = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TGet setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TAuthorization getAuthorizations() {
+ return this.authorizations;
+ }
+
+ public TGet setAuthorizations(@org.apache.thrift.annotation.Nullable TAuthorization authorizations) {
+ this.authorizations = authorizations;
+ return this;
+ }
+
+ public void unsetAuthorizations() {
+ this.authorizations = null;
+ }
+
+ /** Returns true if field authorizations is set (has been assigned a value) and false otherwise */
+ public boolean isSetAuthorizations() {
+ return this.authorizations != null;
+ }
+
+ public void setAuthorizationsIsSet(boolean value) {
+ if (!value) {
+ this.authorizations = null;
+ }
+ }
+
+ /**
+ *
+ * @see TConsistency
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TConsistency getConsistency() {
+ return this.consistency;
+ }
+
+ /**
+ *
+ * @see TConsistency
+ */
+ public TGet setConsistency(@org.apache.thrift.annotation.Nullable TConsistency consistency) {
+ this.consistency = consistency;
+ return this;
+ }
+
+ public void unsetConsistency() {
+ this.consistency = null;
+ }
+
+ /** Returns true if field consistency is set (has been assigned a value) and false otherwise */
+ public boolean isSetConsistency() {
+ return this.consistency != null;
+ }
+
+ public void setConsistencyIsSet(boolean value) {
+ if (!value) {
+ this.consistency = null;
+ }
+ }
+
+ public int getTargetReplicaId() {
+ return this.targetReplicaId;
+ }
+
+ public TGet setTargetReplicaId(int targetReplicaId) {
+ this.targetReplicaId = targetReplicaId;
+ setTargetReplicaIdIsSet(true);
+ return this;
+ }
+
+ public void unsetTargetReplicaId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID);
+ }
+
+ /** Returns true if field targetReplicaId is set (has been assigned a value) and false otherwise */
+ public boolean isSetTargetReplicaId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID);
+ }
+
+ public void setTargetReplicaIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID, value);
+ }
+
+ public boolean isCacheBlocks() {
+ return this.cacheBlocks;
+ }
+
+ public TGet setCacheBlocks(boolean cacheBlocks) {
+ this.cacheBlocks = cacheBlocks;
+ setCacheBlocksIsSet(true);
+ return this;
+ }
+
+ public void unsetCacheBlocks() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
+ }
+
+ /** Returns true if field cacheBlocks is set (has been assigned a value) and false otherwise */
+ public boolean isSetCacheBlocks() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
+ }
+
+ public void setCacheBlocksIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID, value);
+ }
+
+ public int getStoreLimit() {
+ return this.storeLimit;
+ }
+
+ public TGet setStoreLimit(int storeLimit) {
+ this.storeLimit = storeLimit;
+ setStoreLimitIsSet(true);
+ return this;
+ }
+
+ public void unsetStoreLimit() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __STORELIMIT_ISSET_ID);
+ }
+
+ /** Returns true if field storeLimit is set (has been assigned a value) and false otherwise */
+ public boolean isSetStoreLimit() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __STORELIMIT_ISSET_ID);
+ }
+
+ public void setStoreLimitIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __STORELIMIT_ISSET_ID, value);
+ }
+
+ public int getStoreOffset() {
+ return this.storeOffset;
+ }
+
+ public TGet setStoreOffset(int storeOffset) {
+ this.storeOffset = storeOffset;
+ setStoreOffsetIsSet(true);
+ return this;
+ }
+
+ public void unsetStoreOffset() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __STOREOFFSET_ISSET_ID);
+ }
+
+ /** Returns true if field storeOffset is set (has been assigned a value) and false otherwise */
+ public boolean isSetStoreOffset() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __STOREOFFSET_ISSET_ID);
+ }
+
+ public void setStoreOffsetIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __STOREOFFSET_ISSET_ID, value);
+ }
+
+ public boolean isExistence_only() {
+ return this.existence_only;
+ }
+
+ public TGet setExistence_only(boolean existence_only) {
+ this.existence_only = existence_only;
+ setExistence_onlyIsSet(true);
+ return this;
+ }
+
+ public void unsetExistence_only() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __EXISTENCE_ONLY_ISSET_ID);
+ }
+
+ /** Returns true if field existence_only is set (has been assigned a value) and false otherwise */
+ public boolean isSetExistence_only() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __EXISTENCE_ONLY_ISSET_ID);
+ }
+
+ public void setExistence_onlyIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __EXISTENCE_ONLY_ISSET_ID, value);
+ }
+
+ public byte[] getFilterBytes() {
+ setFilterBytes(org.apache.thrift.TBaseHelper.rightSize(filterBytes));
+ return filterBytes == null ? null : filterBytes.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFilterBytes() {
+ return org.apache.thrift.TBaseHelper.copyBinary(filterBytes);
+ }
+
+ public TGet setFilterBytes(byte[] filterBytes) {
+ this.filterBytes = filterBytes == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(filterBytes.clone());
+ return this;
+ }
+
+ public TGet setFilterBytes(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterBytes) {
+ this.filterBytes = org.apache.thrift.TBaseHelper.copyBinary(filterBytes);
+ return this;
+ }
+
+ public void unsetFilterBytes() {
+ this.filterBytes = null;
+ }
+
+ /** Returns true if field filterBytes is set (has been assigned a value) and false otherwise */
+ public boolean isSetFilterBytes() {
+ return this.filterBytes != null;
+ }
+
+ public void setFilterBytesIsSet(boolean value) {
+ if (!value) {
+ this.filterBytes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<TColumn>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case TIME_RANGE:
+ if (value == null) {
+ unsetTimeRange();
+ } else {
+ setTimeRange((TTimeRange)value);
+ }
+ break;
+
+ case MAX_VERSIONS:
+ if (value == null) {
+ unsetMaxVersions();
+ } else {
+ setMaxVersions((java.lang.Integer)value);
+ }
+ break;
+
+ case FILTER_STRING:
+ if (value == null) {
+ unsetFilterString();
+ } else {
+ if (value instanceof byte[]) {
+ setFilterString((byte[])value);
+ } else {
+ setFilterString((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case AUTHORIZATIONS:
+ if (value == null) {
+ unsetAuthorizations();
+ } else {
+ setAuthorizations((TAuthorization)value);
+ }
+ break;
+
+ case CONSISTENCY:
+ if (value == null) {
+ unsetConsistency();
+ } else {
+ setConsistency((TConsistency)value);
+ }
+ break;
+
+ case TARGET_REPLICA_ID:
+ if (value == null) {
+ unsetTargetReplicaId();
+ } else {
+ setTargetReplicaId((java.lang.Integer)value);
+ }
+ break;
+
+ case CACHE_BLOCKS:
+ if (value == null) {
+ unsetCacheBlocks();
+ } else {
+ setCacheBlocks((java.lang.Boolean)value);
+ }
+ break;
+
+ case STORE_LIMIT:
+ if (value == null) {
+ unsetStoreLimit();
+ } else {
+ setStoreLimit((java.lang.Integer)value);
+ }
+ break;
+
+ case STORE_OFFSET:
+ if (value == null) {
+ unsetStoreOffset();
+ } else {
+ setStoreOffset((java.lang.Integer)value);
+ }
+ break;
+
+ case EXISTENCE_ONLY:
+ if (value == null) {
+ unsetExistence_only();
+ } else {
+ setExistence_only((java.lang.Boolean)value);
+ }
+ break;
+
+ case FILTER_BYTES:
+ if (value == null) {
+ unsetFilterBytes();
+ } else {
+ if (value instanceof byte[]) {
+ setFilterBytes((byte[])value);
+ } else {
+ setFilterBytes((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case TIME_RANGE:
+ return getTimeRange();
+
+ case MAX_VERSIONS:
+ return getMaxVersions();
+
+ case FILTER_STRING:
+ return getFilterString();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case AUTHORIZATIONS:
+ return getAuthorizations();
+
+ case CONSISTENCY:
+ return getConsistency();
+
+ case TARGET_REPLICA_ID:
+ return getTargetReplicaId();
+
+ case CACHE_BLOCKS:
+ return isCacheBlocks();
+
+ case STORE_LIMIT:
+ return getStoreLimit();
+
+ case STORE_OFFSET:
+ return getStoreOffset();
+
+ case EXISTENCE_ONLY:
+ return isExistence_only();
+
+ case FILTER_BYTES:
+ return getFilterBytes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case TIME_RANGE:
+ return isSetTimeRange();
+ case MAX_VERSIONS:
+ return isSetMaxVersions();
+ case FILTER_STRING:
+ return isSetFilterString();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case AUTHORIZATIONS:
+ return isSetAuthorizations();
+ case CONSISTENCY:
+ return isSetConsistency();
+ case TARGET_REPLICA_ID:
+ return isSetTargetReplicaId();
+ case CACHE_BLOCKS:
+ return isSetCacheBlocks();
+ case STORE_LIMIT:
+ return isSetStoreLimit();
+ case STORE_OFFSET:
+ return isSetStoreOffset();
+ case EXISTENCE_ONLY:
+ return isSetExistence_only();
+ case FILTER_BYTES:
+ return isSetFilterBytes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TGet)
+ return this.equals((TGet)that);
+ return false;
+ }
+
+ public boolean equals(TGet that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_timestamp = true && this.isSetTimestamp();
+ boolean that_present_timestamp = true && that.isSetTimestamp();
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_timeRange = true && this.isSetTimeRange();
+ boolean that_present_timeRange = true && that.isSetTimeRange();
+ if (this_present_timeRange || that_present_timeRange) {
+ if (!(this_present_timeRange && that_present_timeRange))
+ return false;
+ if (!this.timeRange.equals(that.timeRange))
+ return false;
+ }
+
+ boolean this_present_maxVersions = true && this.isSetMaxVersions();
+ boolean that_present_maxVersions = true && that.isSetMaxVersions();
+ if (this_present_maxVersions || that_present_maxVersions) {
+ if (!(this_present_maxVersions && that_present_maxVersions))
+ return false;
+ if (this.maxVersions != that.maxVersions)
+ 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;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_authorizations = true && this.isSetAuthorizations();
+ boolean that_present_authorizations = true && that.isSetAuthorizations();
+ if (this_present_authorizations || that_present_authorizations) {
+ if (!(this_present_authorizations && that_present_authorizations))
+ return false;
+ if (!this.authorizations.equals(that.authorizations))
+ return false;
+ }
+
+ boolean this_present_consistency = true && this.isSetConsistency();
+ boolean that_present_consistency = true && that.isSetConsistency();
+ if (this_present_consistency || that_present_consistency) {
+ if (!(this_present_consistency && that_present_consistency))
+ return false;
+ if (!this.consistency.equals(that.consistency))
+ return false;
+ }
+
+ boolean this_present_targetReplicaId = true && this.isSetTargetReplicaId();
+ boolean that_present_targetReplicaId = true && that.isSetTargetReplicaId();
+ if (this_present_targetReplicaId || that_present_targetReplicaId) {
+ if (!(this_present_targetReplicaId && that_present_targetReplicaId))
+ return false;
+ if (this.targetReplicaId != that.targetReplicaId)
+ return false;
+ }
+
+ boolean this_present_cacheBlocks = true && this.isSetCacheBlocks();
+ boolean that_present_cacheBlocks = true && that.isSetCacheBlocks();
+ if (this_present_cacheBlocks || that_present_cacheBlocks) {
+ if (!(this_present_cacheBlocks && that_present_cacheBlocks))
+ return false;
+ if (this.cacheBlocks != that.cacheBlocks)
+ return false;
+ }
+
+ boolean this_present_storeLimit = true && this.isSetStoreLimit();
+ boolean that_present_storeLimit = true && that.isSetStoreLimit();
+ if (this_present_storeLimit || that_present_storeLimit) {
+ if (!(this_present_storeLimit && that_present_storeLimit))
+ return false;
+ if (this.storeLimit != that.storeLimit)
+ return false;
+ }
+
+ boolean this_present_storeOffset = true && this.isSetStoreOffset();
+ boolean that_present_storeOffset = true && that.isSetStoreOffset();
+ if (this_present_storeOffset || that_present_storeOffset) {
+ if (!(this_present_storeOffset && that_present_storeOffset))
+ return false;
+ if (this.storeOffset != that.storeOffset)
+ return false;
+ }
+
+ boolean this_present_existence_only = true && this.isSetExistence_only();
+ boolean that_present_existence_only = true && that.isSetExistence_only();
+ if (this_present_existence_only || that_present_existence_only) {
+ if (!(this_present_existence_only && that_present_existence_only))
+ return false;
+ if (this.existence_only != that.existence_only)
+ return false;
+ }
+
+ boolean this_present_filterBytes = true && this.isSetFilterBytes();
+ boolean that_present_filterBytes = true && that.isSetFilterBytes();
+ if (this_present_filterBytes || that_present_filterBytes) {
+ if (!(this_present_filterBytes && that_present_filterBytes))
+ return false;
+ if (!this.filterBytes.equals(that.filterBytes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTimestamp()) ? 131071 : 524287);
+ if (isSetTimestamp())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetTimeRange()) ? 131071 : 524287);
+ if (isSetTimeRange())
+ hashCode = hashCode * 8191 + timeRange.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetMaxVersions()) ? 131071 : 524287);
+ if (isSetMaxVersions())
+ hashCode = hashCode * 8191 + maxVersions;
+
+ hashCode = hashCode * 8191 + ((isSetFilterString()) ? 131071 : 524287);
+ if (isSetFilterString())
+ hashCode = hashCode * 8191 + filterString.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAuthorizations()) ? 131071 : 524287);
+ if (isSetAuthorizations())
+ hashCode = hashCode * 8191 + authorizations.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetConsistency()) ? 131071 : 524287);
+ if (isSetConsistency())
+ hashCode = hashCode * 8191 + consistency.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetTargetReplicaId()) ? 131071 : 524287);
+ if (isSetTargetReplicaId())
+ hashCode = hashCode * 8191 + targetReplicaId;
+
+ hashCode = hashCode * 8191 + ((isSetCacheBlocks()) ? 131071 : 524287);
+ if (isSetCacheBlocks())
+ hashCode = hashCode * 8191 + ((cacheBlocks) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetStoreLimit()) ? 131071 : 524287);
+ if (isSetStoreLimit())
+ hashCode = hashCode * 8191 + storeLimit;
+
+ hashCode = hashCode * 8191 + ((isSetStoreOffset()) ? 131071 : 524287);
+ if (isSetStoreOffset())
+ hashCode = hashCode * 8191 + storeOffset;
+
+ hashCode = hashCode * 8191 + ((isSetExistence_only()) ? 131071 : 524287);
+ if (isSetExistence_only())
+ hashCode = hashCode * 8191 + ((existence_only) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetFilterBytes()) ? 131071 : 524287);
+ if (isSetFilterBytes())
+ hashCode = hashCode * 8191 + filterBytes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TGet other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimeRange(), other.isSetTimeRange());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimeRange()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeRange, other.timeRange);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMaxVersions(), other.isSetMaxVersions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMaxVersions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxVersions, other.maxVersions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFilterString(), other.isSetFilterString());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFilterString()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterString, other.filterString);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAuthorizations(), other.isSetAuthorizations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAuthorizations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authorizations, other.authorizations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetConsistency(), other.isSetConsistency());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetConsistency()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.consistency, other.consistency);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTargetReplicaId(), other.isSetTargetReplicaId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTargetReplicaId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.targetReplicaId, other.targetReplicaId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCacheBlocks(), other.isSetCacheBlocks());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCacheBlocks()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheBlocks, other.cacheBlocks);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStoreLimit(), other.isSetStoreLimit());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStoreLimit()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.storeLimit, other.storeLimit);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStoreOffset(), other.isSetStoreOffset());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStoreOffset()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.storeOffset, other.storeOffset);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetExistence_only(), other.isSetExistence_only());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetExistence_only()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.existence_only, other.existence_only);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFilterBytes(), other.isSetFilterBytes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFilterBytes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterBytes, other.filterBytes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TGet(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (isSetColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columns);
+ }
+ first = false;
+ }
+ if (isSetTimestamp()) {
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ }
+ if (isSetTimeRange()) {
+ if (!first) sb.append(", ");
+ sb.append("timeRange:");
+ if (this.timeRange == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.timeRange);
+ }
+ first = false;
+ }
+ if (isSetMaxVersions()) {
+ if (!first) sb.append(", ");
+ sb.append("maxVersions:");
+ sb.append(this.maxVersions);
+ first = false;
+ }
+ if (isSetFilterString()) {
+ if (!first) sb.append(", ");
+ sb.append("filterString:");
+ if (this.filterString == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.filterString, sb);
+ }
+ first = false;
+ }
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetAuthorizations()) {
+ if (!first) sb.append(", ");
+ sb.append("authorizations:");
+ if (this.authorizations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.authorizations);
+ }
+ first = false;
+ }
+ if (isSetConsistency()) {
+ if (!first) sb.append(", ");
+ sb.append("consistency:");
+ if (this.consistency == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.consistency);
+ }
+ first = false;
+ }
+ if (isSetTargetReplicaId()) {
+ if (!first) sb.append(", ");
+ sb.append("targetReplicaId:");
+ sb.append(this.targetReplicaId);
+ first = false;
+ }
+ if (isSetCacheBlocks()) {
+ if (!first) sb.append(", ");
+ sb.append("cacheBlocks:");
+ sb.append(this.cacheBlocks);
+ first = false;
+ }
+ if (isSetStoreLimit()) {
+ if (!first) sb.append(", ");
+ sb.append("storeLimit:");
+ sb.append(this.storeLimit);
+ first = false;
+ }
+ if (isSetStoreOffset()) {
+ if (!first) sb.append(", ");
+ sb.append("storeOffset:");
+ sb.append(this.storeOffset);
+ first = false;
+ }
+ if (isSetExistence_only()) {
+ if (!first) sb.append(", ");
+ sb.append("existence_only:");
+ sb.append(this.existence_only);
+ first = false;
+ }
+ if (isSetFilterBytes()) {
+ if (!first) sb.append(", ");
+ sb.append("filterBytes:");
+ if (this.filterBytes == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.filterBytes, sb);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (timeRange != null) {
+ timeRange.validate();
+ }
+ if (authorizations != null) {
+ authorizations.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TGetStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TGetStandardScheme getScheme() {
+ return new TGetStandardScheme();
+ }
+ }
+
+ private static class TGetStandardScheme extends org.apache.thrift.scheme.StandardScheme<TGet> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TGet struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list16 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<TColumn>(_list16.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem17;
+ for (int _i18 = 0; _i18 < _list16.size; ++_i18)
+ {
+ _elem17 = new TColumn();
+ _elem17.read(iprot);
+ struct.columns.add(_elem17);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TIME_RANGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.timeRange = new TTimeRange();
+ struct.timeRange.read(iprot);
+ struct.setTimeRangeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // MAX_VERSIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // FILTER_STRING
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.filterString = iprot.readBinary();
+ struct.setFilterStringIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map19 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map19.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key20;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val21;
+ for (int _i22 = 0; _i22 < _map19.size; ++_i22)
+ {
+ _key20 = iprot.readBinary();
+ _val21 = iprot.readBinary();
+ struct.attributes.put(_key20, _val21);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 8: // AUTHORIZATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.authorizations = new TAuthorization();
+ struct.authorizations.read(iprot);
+ struct.setAuthorizationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 9: // CONSISTENCY
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.consistency = org.apache.hadoop.hbase.thrift2.generated.TConsistency.findByValue(iprot.readI32());
+ struct.setConsistencyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 10: // TARGET_REPLICA_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.targetReplicaId = iprot.readI32();
+ struct.setTargetReplicaIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 11: // CACHE_BLOCKS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.cacheBlocks = iprot.readBool();
+ struct.setCacheBlocksIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 12: // STORE_LIMIT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.storeLimit = iprot.readI32();
+ struct.setStoreLimitIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 13: // STORE_OFFSET
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.storeOffset = iprot.readI32();
+ struct.setStoreOffsetIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 14: // EXISTENCE_ONLY
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.existence_only = iprot.readBool();
+ struct.setExistence_onlyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 15: // FILTER_BYTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.filterBytes = iprot.readBinary();
+ struct.setFilterBytesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TGet struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ if (struct.isSetColumns()) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+ for (TColumn _iter23 : struct.columns)
+ {
+ _iter23.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ }
+ if (struct.timeRange != null) {
+ if (struct.isSetTimeRange()) {
+ oprot.writeFieldBegin(TIME_RANGE_FIELD_DESC);
+ struct.timeRange.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetMaxVersions()) {
+ oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
+ oprot.writeI32(struct.maxVersions);
+ oprot.writeFieldEnd();
+ }
+ if (struct.filterString != null) {
+ if (struct.isSetFilterString()) {
+ oprot.writeFieldBegin(FILTER_STRING_FIELD_DESC);
+ oprot.writeBinary(struct.filterString);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter24 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter24.getKey());
+ oprot.writeBinary(_iter24.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.authorizations != null) {
+ if (struct.isSetAuthorizations()) {
+ oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC);
+ struct.authorizations.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.consistency != null) {
+ if (struct.isSetConsistency()) {
+ oprot.writeFieldBegin(CONSISTENCY_FIELD_DESC);
+ oprot.writeI32(struct.consistency.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetTargetReplicaId()) {
+ oprot.writeFieldBegin(TARGET_REPLICA_ID_FIELD_DESC);
+ oprot.writeI32(struct.targetReplicaId);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetCacheBlocks()) {
+ oprot.writeFieldBegin(CACHE_BLOCKS_FIELD_DESC);
+ oprot.writeBool(struct.cacheBlocks);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetStoreLimit()) {
+ oprot.writeFieldBegin(STORE_LIMIT_FIELD_DESC);
+ oprot.writeI32(struct.storeLimit);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetStoreOffset()) {
+ oprot.writeFieldBegin(STORE_OFFSET_FIELD_DESC);
+ oprot.writeI32(struct.storeOffset);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetExistence_only()) {
+ oprot.writeFieldBegin(EXISTENCE_ONLY_FIELD_DESC);
+ oprot.writeBool(struct.existence_only);
+ oprot.writeFieldEnd();
+ }
+ if (struct.filterBytes != null) {
+ if (struct.isSetFilterBytes()) {
+ oprot.writeFieldBegin(FILTER_BYTES_FIELD_DESC);
+ oprot.writeBinary(struct.filterBytes);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TGetTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TGetTupleScheme getScheme() {
+ return new TGetTupleScheme();
+ }
+ }
+
+ private static class TGetTupleScheme extends org.apache.thrift.scheme.TupleScheme<TGet> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TGet struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.row);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetColumns()) {
+ optionals.set(0);
+ }
+ if (struct.isSetTimestamp()) {
+ optionals.set(1);
+ }
+ if (struct.isSetTimeRange()) {
+ optionals.set(2);
+ }
+ if (struct.isSetMaxVersions()) {
+ optionals.set(3);
+ }
+ if (struct.isSetFilterString()) {
+ optionals.set(4);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(5);
+ }
+ if (struct.isSetAuthorizations()) {
+ optionals.set(6);
+ }
+ if (struct.isSetConsistency()) {
+ optionals.set(7);
+ }
+ if (struct.isSetTargetReplicaId()) {
+ optionals.set(8);
+ }
+ if (struct.isSetCacheBlocks()) {
+ optionals.set(9);
+ }
+ if (struct.isSetStoreLimit()) {
+ optionals.set(10);
+ }
+ if (struct.isSetStoreOffset()) {
+ optionals.set(11);
+ }
+ if (struct.isSetExistence_only()) {
+ optionals.set(12);
+ }
+ if (struct.isSetFilterBytes()) {
+ optionals.set(13);
+ }
+ oprot.writeBitSet(optionals, 14);
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (TColumn _iter25 : struct.columns)
+ {
+ _iter25.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetTimeRange()) {
+ struct.timeRange.write(oprot);
+ }
+ if (struct.isSetMaxVersions()) {
+ oprot.writeI32(struct.maxVersions);
+ }
+ if (struct.isSetFilterString()) {
+ oprot.writeBinary(struct.filterString);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter26 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter26.getKey());
+ oprot.writeBinary(_iter26.getValue());
+ }
+ }
+ }
+ if (struct.isSetAuthorizations()) {
+ struct.authorizations.write(oprot);
+ }
+ if (struct.isSetConsistency()) {
+ oprot.writeI32(struct.consistency.getValue());
+ }
+ if (struct.isSetTargetReplicaId()) {
+ oprot.writeI32(struct.targetReplicaId);
+ }
+ if (struct.isSetCacheBlocks()) {
+ oprot.writeBool(struct.cacheBlocks);
+ }
+ if (struct.isSetStoreLimit()) {
+ oprot.writeI32(struct.storeLimit);
+ }
+ if (struct.isSetStoreOffset()) {
+ oprot.writeI32(struct.storeOffset);
+ }
+ if (struct.isSetExistence_only()) {
+ oprot.writeBool(struct.existence_only);
+ }
+ if (struct.isSetFilterBytes()) {
+ oprot.writeBinary(struct.filterBytes);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TGet struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(14);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list27 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columns = new java.util.ArrayList<TColumn>(_list27.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem28;
+ for (int _i29 = 0; _i29 < _list27.size; ++_i29)
+ {
+ _elem28 = new TColumn();
+ _elem28.read(iprot);
+ struct.columns.add(_elem28);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.timeRange = new TTimeRange();
+ struct.timeRange.read(iprot);
+ struct.setTimeRangeIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.filterString = iprot.readBinary();
+ struct.setFilterStringIsSet(true);
+ }
+ if (incoming.get(5)) {
+ {
+ org.apache.thrift.protocol.TMap _map30 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map30.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key31;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val32;
+ for (int _i33 = 0; _i33 < _map30.size; ++_i33)
+ {
+ _key31 = iprot.readBinary();
+ _val32 = iprot.readBinary();
+ struct.attributes.put(_key31, _val32);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.authorizations = new TAuthorization();
+ struct.authorizations.read(iprot);
+ struct.setAuthorizationsIsSet(true);
+ }
+ if (incoming.get(7)) {
+ struct.consistency = org.apache.hadoop.hbase.thrift2.generated.TConsistency.findByValue(iprot.readI32());
+ struct.setConsistencyIsSet(true);
+ }
+ if (incoming.get(8)) {
+ struct.targetReplicaId = iprot.readI32();
+ struct.setTargetReplicaIdIsSet(true);
+ }
+ if (incoming.get(9)) {
+ struct.cacheBlocks = iprot.readBool();
+ struct.setCacheBlocksIsSet(true);
+ }
+ if (incoming.get(10)) {
+ struct.storeLimit = iprot.readI32();
+ struct.setStoreLimitIsSet(true);
+ }
+ if (incoming.get(11)) {
+ struct.storeOffset = iprot.readI32();
+ struct.setStoreOffsetIsSet(true);
+ }
+ if (incoming.get(12)) {
+ struct.existence_only = iprot.readBool();
+ struct.setExistence_onlyIsSet(true);
+ }
+ if (incoming.get(13)) {
+ struct.filterBytes = iprot.readBinary();
+ struct.setFilterBytesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THBaseService.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THBaseService.java
new file mode 100644
index 0000000..0fde1db
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THBaseService.java
@@ -0,0 +1,57060 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class THBaseService {
+
+ public interface Iface {
+
+ /**
+ * Test for the existence of columns in the table, as specified in the TGet.
+ *
+ * @return true if the specified TGet matches one or more keys, false if not
+ *
+ * @param table the table to check on
+ *
+ * @param tget the TGet to check for
+ */
+ public boolean exists(java.nio.ByteBuffer table, TGet tget) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Test for the existence of columns in the table, as specified by the TGets.
+ *
+ * This will return an array of booleans. Each value will be true if the related Get matches
+ * one or more keys, false if not.
+ *
+ * @param table the table to check on
+ *
+ * @param tgets a list of TGets to check for
+ */
+ public java.util.List<java.lang.Boolean> existsAll(java.nio.ByteBuffer table, java.util.List<TGet> tgets) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Method for getting data from a row.
+ *
+ * If the row cannot be found an empty Result is returned.
+ * This can be checked by the empty field of the TResult
+ *
+ * @return the result
+ *
+ * @param table the table to get from
+ *
+ * @param tget the TGet to fetch
+ */
+ public TResult get(java.nio.ByteBuffer table, TGet tget) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Method for getting multiple rows.
+ *
+ * If a row cannot be found there will be a null
+ * value in the result list for that TGet at the
+ * same position.
+ *
+ * So the Results are in the same order as the TGets.
+ *
+ * @param table the table to get from
+ *
+ * @param tgets a list of TGets to fetch, the Result list
+ * will have the Results at corresponding positions
+ * or null if there was an error
+ */
+ public java.util.List<TResult> getMultiple(java.nio.ByteBuffer table, java.util.List<TGet> tgets) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Commit a TPut to a table.
+ *
+ * @param table the table to put data in
+ *
+ * @param tput the TPut to put
+ */
+ public void put(java.nio.ByteBuffer table, TPut tput) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it adds the TPut.
+ *
+ * @return true if the new put was executed, false otherwise
+ *
+ * @param table to check in and put to
+ *
+ * @param row row to check
+ *
+ * @param family column family to check
+ *
+ * @param qualifier column qualifier to check
+ *
+ * @param value the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ *
+ * @param tput the TPut to put if the check succeeds
+ */
+ public boolean checkAndPut(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TPut tput) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Commit a List of Puts to the table.
+ *
+ * @param table the table to put data in
+ *
+ * @param tputs a list of TPuts to commit
+ */
+ public void putMultiple(java.nio.ByteBuffer table, java.util.List<TPut> tputs) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Deletes as specified by the TDelete.
+ *
+ * Note: "delete" is a reserved keyword and cannot be used in Thrift
+ * thus the inconsistent naming scheme from the other functions.
+ *
+ * @param table the table to delete from
+ *
+ * @param tdelete the TDelete to delete
+ */
+ public void deleteSingle(java.nio.ByteBuffer table, TDelete tdelete) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Bulk commit a List of TDeletes to the table.
+ *
+ * Throws a TIOError if any of the deletes fail.
+ *
+ * Always returns an empty list for backwards compatibility.
+ *
+ * @param table the table to delete from
+ *
+ * @param tdeletes list of TDeletes to delete
+ */
+ public java.util.List<TDelete> deleteMultiple(java.nio.ByteBuffer table, java.util.List<TDelete> tdeletes) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it adds the delete.
+ *
+ * @return true if the new delete was executed, false otherwise
+ *
+ * @param table to check in and delete from
+ *
+ * @param row row to check
+ *
+ * @param family column family to check
+ *
+ * @param qualifier column qualifier to check
+ *
+ * @param value the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ *
+ * @param tdelete the TDelete to execute if the check succeeds
+ */
+ public boolean checkAndDelete(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TDelete tdelete) throws TIOError, org.apache.thrift.TException;
+
+ public TResult increment(java.nio.ByteBuffer table, TIncrement tincrement) throws TIOError, org.apache.thrift.TException;
+
+ public TResult append(java.nio.ByteBuffer table, TAppend tappend) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get a Scanner for the provided TScan object.
+ *
+ * @return Scanner Id to be used with other scanner procedures
+ *
+ * @param table the table to get the Scanner for
+ *
+ * @param tscan the scan object to get a Scanner for
+ */
+ public int openScanner(java.nio.ByteBuffer table, TScan tscan) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Grabs multiple rows from a Scanner.
+ *
+ * @return Between zero and numRows TResults
+ *
+ * @param scannerId the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+ *
+ * @param numRows number of rows to return
+ */
+ public java.util.List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * Closes the scanner. Should be called to free server side resources timely.
+ * Typically close once the scanner is not needed anymore, i.e. after looping
+ * over it to get all the required rows.
+ *
+ * @param scannerId the Id of the Scanner to close *
+ */
+ public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
+
+ /**
+ * mutateRow performs multiple mutations atomically on a single row.
+ *
+ * @param table table to apply the mutations
+ *
+ * @param trowMutations mutations to apply
+ */
+ public void mutateRow(java.nio.ByteBuffer table, TRowMutations trowMutations) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get results for the provided TScan object.
+ * This helper function opens a scanner, get the results and close the scanner.
+ *
+ * @return between zero and numRows TResults
+ *
+ * @param table the table to get the Scanner for
+ *
+ * @param tscan the scan object to get a Scanner for
+ *
+ * @param numRows number of rows to return
+ */
+ public java.util.List<TResult> getScannerResults(java.nio.ByteBuffer table, TScan tscan, int numRows) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Given a table and a row get the location of the region that
+ * would contain the given row key.
+ *
+ * reload = true means the cache will be cleared and the location
+ * will be fetched from meta.
+ *
+ * @param table
+ * @param row
+ * @param reload
+ */
+ public THRegionLocation getRegionLocation(java.nio.ByteBuffer table, java.nio.ByteBuffer row, boolean reload) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get all of the region locations for a given table.
+ *
+ *
+ * @param table
+ */
+ public java.util.List<THRegionLocation> getAllRegionLocations(java.nio.ByteBuffer table) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it mutates the row.
+ *
+ * @return true if the row was mutated, false otherwise
+ *
+ * @param table to check in and delete from
+ *
+ * @param row row to check
+ *
+ * @param family column family to check
+ *
+ * @param qualifier column qualifier to check
+ *
+ * @param compareOperator comparison to make on the value
+ *
+ * @param value the expected value to be compared against, if not provided the
+ * check is for the non-existence of the column in question
+ *
+ * @param rowMutations row mutations to execute if the value matches
+ */
+ public boolean checkAndMutate(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, TCompareOperator compareOperator, java.nio.ByteBuffer value, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get a table descriptor.
+ * @return the TableDescriptor of the giving tablename
+ *
+ *
+ * @param table the tablename of the table to get tableDescriptor
+ */
+ public TTableDescriptor getTableDescriptor(TTableName table) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get table descriptors of tables.
+ * @return the TableDescriptor of the giving tablename
+ *
+ *
+ * @param tables the tablename list of the tables to get tableDescriptor
+ */
+ public java.util.List<TTableDescriptor> getTableDescriptors(java.util.List<TTableName> tables) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ *
+ * @return true if table exists already, false if not
+ *
+ *
+ * @param tableName the tablename of the tables to check
+ */
+ public boolean tableExists(TTableName tableName) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get table descriptors of tables that match the given pattern
+ * @return the tableDescriptors of the matching table
+ *
+ *
+ * @param regex The regular expression to match against
+ *
+ * @param includeSysTables set to false if match only against userspace tables
+ */
+ public java.util.List<TTableDescriptor> getTableDescriptorsByPattern(java.lang.String regex, boolean includeSysTables) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get table descriptors of tables in the given namespace
+ * @return the tableDescriptors in the namespce
+ *
+ *
+ * @param name The namesapce's name
+ */
+ public java.util.List<TTableDescriptor> getTableDescriptorsByNamespace(java.lang.String name) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get table names of tables that match the given pattern
+ * @return the table names of the matching table
+ *
+ *
+ * @param regex The regular expression to match against
+ *
+ * @param includeSysTables set to false if match only against userspace tables
+ */
+ public java.util.List<TTableName> getTableNamesByPattern(java.lang.String regex, boolean includeSysTables) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get table names of tables in the given namespace
+ * @return the table names of the matching table
+ *
+ *
+ * @param name The namesapce's name
+ */
+ public java.util.List<TTableName> getTableNamesByNamespace(java.lang.String name) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Creates a new table with an initial set of empty regions defined by the specified split keys.
+ * The total number of regions created will be the number of split keys plus one. Synchronous
+ * operation.
+ *
+ *
+ * @param desc table descriptor for table
+ *
+ * @param splitKeys rray of split keys for the initial regions of the table
+ */
+ public void createTable(TTableDescriptor desc, java.util.List<java.nio.ByteBuffer> splitKeys) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Deletes a table. Synchronous operation.
+ *
+ *
+ * @param tableName the tablename to delete
+ */
+ public void deleteTable(TTableName tableName) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Truncate a table. Synchronous operation.
+ *
+ *
+ * @param tableName the tablename to truncate
+ *
+ * @param preserveSplits whether to preserve previous splits
+ */
+ public void truncateTable(TTableName tableName, boolean preserveSplits) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Enalbe a table
+ *
+ *
+ * @param tableName the tablename to enable
+ */
+ public void enableTable(TTableName tableName) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Disable a table
+ *
+ *
+ * @param tableName the tablename to disable
+ */
+ public void disableTable(TTableName tableName) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ *
+ * @return true if table is enabled, false if not
+ *
+ *
+ * @param tableName the tablename to check
+ */
+ public boolean isTableEnabled(TTableName tableName) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ *
+ * @return true if table is disabled, false if not
+ *
+ *
+ * @param tableName the tablename to check
+ */
+ public boolean isTableDisabled(TTableName tableName) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ *
+ * @return true if table is available, false if not
+ *
+ *
+ * @param tableName the tablename to check
+ */
+ public boolean isTableAvailable(TTableName tableName) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * * Use this api to check if the table has been created with the specified number of splitkeys
+ * * which was used while creating the given table. Note : If this api is used after a table's
+ * * region gets splitted, the api may return false.
+ * *
+ * * @return true if table is available, false if not
+ * *
+ * * @deprecated Since 2.2.0. Because the same method in Table interface has been deprecated
+ * * since 2.0.0, we will remove it in 3.0.0 release.
+ * * Use {@link #isTableAvailable(TTableName tableName)} instead
+ * *
+ *
+ * @param tableName the tablename to check
+ *
+ * @param splitKeys keys to check if the table has been created with all split keys
+ */
+ public boolean isTableAvailableWithSplit(TTableName tableName, java.util.List<java.nio.ByteBuffer> splitKeys) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Add a column family to an existing table. Synchronous operation.
+ *
+ *
+ * @param tableName the tablename to add column family to
+ *
+ * @param column column family descriptor of column family to be added
+ */
+ public void addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Delete a column family from a table. Synchronous operation.
+ *
+ *
+ * @param tableName the tablename to delete column family from
+ *
+ * @param column name of column family to be deleted
+ */
+ public void deleteColumnFamily(TTableName tableName, java.nio.ByteBuffer column) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Modify an existing column family on a table. Synchronous operation.
+ *
+ *
+ * @param tableName the tablename to modify column family
+ *
+ * @param column column family descriptor of column family to be modified
+ */
+ public void modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Modify an existing table
+ *
+ *
+ * @param desc the descriptor of the table to modify
+ */
+ public void modifyTable(TTableDescriptor desc) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Create a new namespace. Blocks until namespace has been successfully created or an exception is
+ * thrown
+ *
+ *
+ * @param namespaceDesc descriptor which describes the new namespace
+ */
+ public void createNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Modify an existing namespace. Blocks until namespace has been successfully modified or an
+ * exception is thrown
+ *
+ *
+ * @param namespaceDesc descriptor which describes the new namespace
+ */
+ public void modifyNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Delete an existing namespace. Only empty namespaces (no tables) can be removed.
+ * Blocks until namespace has been successfully deleted or an
+ * exception is thrown.
+ *
+ *
+ * @param name namespace name
+ */
+ public void deleteNamespace(java.lang.String name) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get a namespace descriptor by name.
+ * @retrun the descriptor
+ *
+ *
+ * @param name name of namespace descriptor
+ */
+ public TNamespaceDescriptor getNamespaceDescriptor(java.lang.String name) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * @return all namespaces
+ *
+ */
+ public java.util.List<TNamespaceDescriptor> listNamespaceDescriptors() throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * @return all namespace names
+ *
+ */
+ public java.util.List<java.lang.String> listNamespaces() throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Get the type of this thrift server.
+ *
+ * @return the type of this thrift server
+ */
+ public TThriftServerType getThriftServerType() throws org.apache.thrift.TException;
+
+ /**
+ * Returns the cluster ID for this cluster.
+ */
+ public java.lang.String getClusterId() throws org.apache.thrift.TException;
+
+ /**
+ * Retrieves online slow RPC logs from the provided list of
+ * RegionServers
+ *
+ * @return online slowlog response list
+ * @throws TIOError if a remote or network exception occurs
+ *
+ * @param serverNames @param serverNames Server names to get slowlog responses from
+ *
+ * @param logQueryFilter @param logQueryFilter filter to be used if provided
+ */
+ public java.util.List<TOnlineLogRecord> getSlowLogResponses(java.util.Set<TServerName> serverNames, TLogQueryFilter logQueryFilter) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Clears online slow/large RPC logs from the provided list of
+ * RegionServers
+ *
+ * @return List of booleans representing if online slowlog response buffer is cleaned
+ * from each RegionServer
+ * @throws TIOError if a remote or network exception occurs
+ *
+ * @param serverNames @param serverNames Set of Server names to clean slowlog responses from
+ */
+ public java.util.List<java.lang.Boolean> clearSlowLogResponses(java.util.Set<TServerName> serverNames) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Grant permissions in table or namespace level.
+ *
+ * @param info
+ */
+ public boolean grant(TAccessControlEntity info) throws TIOError, org.apache.thrift.TException;
+
+ /**
+ * Revoke permissions in table or namespace level.
+ *
+ * @param info
+ */
+ public boolean revoke(TAccessControlEntity info) throws TIOError, org.apache.thrift.TException;
+
+ }
+
+ public interface AsyncIface {
+
+ public void exists(java.nio.ByteBuffer table, TGet tget, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void existsAll(java.nio.ByteBuffer table, java.util.List<TGet> tgets, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException;
+
+ public void get(java.nio.ByteBuffer table, TGet tget, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException;
+
+ public void getMultiple(java.nio.ByteBuffer table, java.util.List<TGet> tgets, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void put(java.nio.ByteBuffer table, TPut tput, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void checkAndPut(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TPut tput, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void putMultiple(java.nio.ByteBuffer table, java.util.List<TPut> tputs, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteSingle(java.nio.ByteBuffer table, TDelete tdelete, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteMultiple(java.nio.ByteBuffer table, java.util.List<TDelete> tdeletes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TDelete>> resultHandler) throws org.apache.thrift.TException;
+
+ public void checkAndDelete(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TDelete tdelete, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void increment(java.nio.ByteBuffer table, TIncrement tincrement, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException;
+
+ public void append(java.nio.ByteBuffer table, TAppend tappend, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException;
+
+ public void openScanner(java.nio.ByteBuffer table, TScan tscan, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException;
+
+ public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void mutateRow(java.nio.ByteBuffer table, TRowMutations trowMutations, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void getScannerResults(java.nio.ByteBuffer table, TScan tscan, int numRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getRegionLocation(java.nio.ByteBuffer table, java.nio.ByteBuffer row, boolean reload, org.apache.thrift.async.AsyncMethodCallback<THRegionLocation> resultHandler) throws org.apache.thrift.TException;
+
+ public void getAllRegionLocations(java.nio.ByteBuffer table, org.apache.thrift.async.AsyncMethodCallback<java.util.List<THRegionLocation>> resultHandler) throws org.apache.thrift.TException;
+
+ public void checkAndMutate(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, TCompareOperator compareOperator, java.nio.ByteBuffer value, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableDescriptor(TTableName table, org.apache.thrift.async.AsyncMethodCallback<TTableDescriptor> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableDescriptors(java.util.List<TTableName> tables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException;
+
+ public void tableExists(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableDescriptorsByPattern(java.lang.String regex, boolean includeSysTables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableDescriptorsByNamespace(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableNamesByPattern(java.lang.String regex, boolean includeSysTables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getTableNamesByNamespace(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler) throws org.apache.thrift.TException;
+
+ public void createTable(TTableDescriptor desc, java.util.List<java.nio.ByteBuffer> splitKeys, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteTable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void truncateTable(TTableName tableName, boolean preserveSplits, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void enableTable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void disableTable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void isTableEnabled(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void isTableDisabled(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void isTableAvailable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void isTableAvailableWithSplit(TTableName tableName, java.util.List<java.nio.ByteBuffer> splitKeys, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteColumnFamily(TTableName tableName, java.nio.ByteBuffer column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void modifyTable(TTableDescriptor desc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void createNamespace(TNamespaceDescriptor namespaceDesc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void modifyNamespace(TNamespaceDescriptor namespaceDesc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void deleteNamespace(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException;
+
+ public void getNamespaceDescriptor(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<TNamespaceDescriptor> resultHandler) throws org.apache.thrift.TException;
+
+ public void listNamespaceDescriptors(org.apache.thrift.async.AsyncMethodCallback<java.util.List<TNamespaceDescriptor>> resultHandler) throws org.apache.thrift.TException;
+
+ public void listNamespaces(org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.String>> resultHandler) throws org.apache.thrift.TException;
+
+ public void getThriftServerType(org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler) throws org.apache.thrift.TException;
+
+ public void getClusterId(org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler) throws org.apache.thrift.TException;
+
+ public void getSlowLogResponses(java.util.Set<TServerName> serverNames, TLogQueryFilter logQueryFilter, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TOnlineLogRecord>> resultHandler) throws org.apache.thrift.TException;
+
+ public void clearSlowLogResponses(java.util.Set<TServerName> serverNames, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException;
+
+ public void grant(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ public void revoke(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException;
+
+ }
+
+ public static class Client extends org.apache.thrift.TServiceClient implements Iface {
+ public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
+ public Factory() {}
+ public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
+ return new Client(prot);
+ }
+ public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
+ return new Client(iprot, oprot);
+ }
+ }
+
+ public Client(org.apache.thrift.protocol.TProtocol prot)
+ {
+ super(prot, prot);
+ }
+
+ public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
+ super(iprot, oprot);
+ }
+
+ public boolean exists(java.nio.ByteBuffer table, TGet tget) throws TIOError, org.apache.thrift.TException
+ {
+ send_exists(table, tget);
+ return recv_exists();
+ }
+
+ public void send_exists(java.nio.ByteBuffer table, TGet tget) throws org.apache.thrift.TException
+ {
+ exists_args args = new exists_args();
+ args.setTable(table);
+ args.setTget(tget);
+ sendBase("exists", args);
+ }
+
+ public boolean recv_exists() throws TIOError, org.apache.thrift.TException
+ {
+ exists_result result = new exists_result();
+ receiveBase(result, "exists");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exists failed: unknown result");
+ }
+
+ public java.util.List<java.lang.Boolean> existsAll(java.nio.ByteBuffer table, java.util.List<TGet> tgets) throws TIOError, org.apache.thrift.TException
+ {
+ send_existsAll(table, tgets);
+ return recv_existsAll();
+ }
+
+ public void send_existsAll(java.nio.ByteBuffer table, java.util.List<TGet> tgets) throws org.apache.thrift.TException
+ {
+ existsAll_args args = new existsAll_args();
+ args.setTable(table);
+ args.setTgets(tgets);
+ sendBase("existsAll", args);
+ }
+
+ public java.util.List<java.lang.Boolean> recv_existsAll() throws TIOError, org.apache.thrift.TException
+ {
+ existsAll_result result = new existsAll_result();
+ receiveBase(result, "existsAll");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "existsAll failed: unknown result");
+ }
+
+ public TResult get(java.nio.ByteBuffer table, TGet tget) throws TIOError, org.apache.thrift.TException
+ {
+ send_get(table, tget);
+ return recv_get();
+ }
+
+ public void send_get(java.nio.ByteBuffer table, TGet tget) throws org.apache.thrift.TException
+ {
+ get_args args = new get_args();
+ args.setTable(table);
+ args.setTget(tget);
+ sendBase("get", args);
+ }
+
+ public TResult recv_get() throws TIOError, org.apache.thrift.TException
+ {
+ get_result result = new get_result();
+ receiveBase(result, "get");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
+ }
+
+ public java.util.List<TResult> getMultiple(java.nio.ByteBuffer table, java.util.List<TGet> tgets) throws TIOError, org.apache.thrift.TException
+ {
+ send_getMultiple(table, tgets);
+ return recv_getMultiple();
+ }
+
+ public void send_getMultiple(java.nio.ByteBuffer table, java.util.List<TGet> tgets) throws org.apache.thrift.TException
+ {
+ getMultiple_args args = new getMultiple_args();
+ args.setTable(table);
+ args.setTgets(tgets);
+ sendBase("getMultiple", args);
+ }
+
+ public java.util.List<TResult> recv_getMultiple() throws TIOError, org.apache.thrift.TException
+ {
+ getMultiple_result result = new getMultiple_result();
+ receiveBase(result, "getMultiple");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
+ }
+
+ public void put(java.nio.ByteBuffer table, TPut tput) throws TIOError, org.apache.thrift.TException
+ {
+ send_put(table, tput);
+ recv_put();
+ }
+
+ public void send_put(java.nio.ByteBuffer table, TPut tput) throws org.apache.thrift.TException
+ {
+ put_args args = new put_args();
+ args.setTable(table);
+ args.setTput(tput);
+ sendBase("put", args);
+ }
+
+ public void recv_put() throws TIOError, org.apache.thrift.TException
+ {
+ put_result result = new put_result();
+ receiveBase(result, "put");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public boolean checkAndPut(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TPut tput) throws TIOError, org.apache.thrift.TException
+ {
+ send_checkAndPut(table, row, family, qualifier, value, tput);
+ return recv_checkAndPut();
+ }
+
+ public void send_checkAndPut(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TPut tput) throws org.apache.thrift.TException
+ {
+ checkAndPut_args args = new checkAndPut_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setFamily(family);
+ args.setQualifier(qualifier);
+ args.setValue(value);
+ args.setTput(tput);
+ sendBase("checkAndPut", args);
+ }
+
+ public boolean recv_checkAndPut() throws TIOError, org.apache.thrift.TException
+ {
+ checkAndPut_result result = new checkAndPut_result();
+ receiveBase(result, "checkAndPut");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
+ }
+
+ public void putMultiple(java.nio.ByteBuffer table, java.util.List<TPut> tputs) throws TIOError, org.apache.thrift.TException
+ {
+ send_putMultiple(table, tputs);
+ recv_putMultiple();
+ }
+
+ public void send_putMultiple(java.nio.ByteBuffer table, java.util.List<TPut> tputs) throws org.apache.thrift.TException
+ {
+ putMultiple_args args = new putMultiple_args();
+ args.setTable(table);
+ args.setTputs(tputs);
+ sendBase("putMultiple", args);
+ }
+
+ public void recv_putMultiple() throws TIOError, org.apache.thrift.TException
+ {
+ putMultiple_result result = new putMultiple_result();
+ receiveBase(result, "putMultiple");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void deleteSingle(java.nio.ByteBuffer table, TDelete tdelete) throws TIOError, org.apache.thrift.TException
+ {
+ send_deleteSingle(table, tdelete);
+ recv_deleteSingle();
+ }
+
+ public void send_deleteSingle(java.nio.ByteBuffer table, TDelete tdelete) throws org.apache.thrift.TException
+ {
+ deleteSingle_args args = new deleteSingle_args();
+ args.setTable(table);
+ args.setTdelete(tdelete);
+ sendBase("deleteSingle", args);
+ }
+
+ public void recv_deleteSingle() throws TIOError, org.apache.thrift.TException
+ {
+ deleteSingle_result result = new deleteSingle_result();
+ receiveBase(result, "deleteSingle");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public java.util.List<TDelete> deleteMultiple(java.nio.ByteBuffer table, java.util.List<TDelete> tdeletes) throws TIOError, org.apache.thrift.TException
+ {
+ send_deleteMultiple(table, tdeletes);
+ return recv_deleteMultiple();
+ }
+
+ public void send_deleteMultiple(java.nio.ByteBuffer table, java.util.List<TDelete> tdeletes) throws org.apache.thrift.TException
+ {
+ deleteMultiple_args args = new deleteMultiple_args();
+ args.setTable(table);
+ args.setTdeletes(tdeletes);
+ sendBase("deleteMultiple", args);
+ }
+
+ public java.util.List<TDelete> recv_deleteMultiple() throws TIOError, org.apache.thrift.TException
+ {
+ deleteMultiple_result result = new deleteMultiple_result();
+ receiveBase(result, "deleteMultiple");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
+ }
+
+ public boolean checkAndDelete(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TDelete tdelete) throws TIOError, org.apache.thrift.TException
+ {
+ send_checkAndDelete(table, row, family, qualifier, value, tdelete);
+ return recv_checkAndDelete();
+ }
+
+ public void send_checkAndDelete(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TDelete tdelete) throws org.apache.thrift.TException
+ {
+ checkAndDelete_args args = new checkAndDelete_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setFamily(family);
+ args.setQualifier(qualifier);
+ args.setValue(value);
+ args.setTdelete(tdelete);
+ sendBase("checkAndDelete", args);
+ }
+
+ public boolean recv_checkAndDelete() throws TIOError, org.apache.thrift.TException
+ {
+ checkAndDelete_result result = new checkAndDelete_result();
+ receiveBase(result, "checkAndDelete");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
+ }
+
+ public TResult increment(java.nio.ByteBuffer table, TIncrement tincrement) throws TIOError, org.apache.thrift.TException
+ {
+ send_increment(table, tincrement);
+ return recv_increment();
+ }
+
+ public void send_increment(java.nio.ByteBuffer table, TIncrement tincrement) throws org.apache.thrift.TException
+ {
+ increment_args args = new increment_args();
+ args.setTable(table);
+ args.setTincrement(tincrement);
+ sendBase("increment", args);
+ }
+
+ public TResult recv_increment() throws TIOError, org.apache.thrift.TException
+ {
+ increment_result result = new increment_result();
+ receiveBase(result, "increment");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "increment failed: unknown result");
+ }
+
+ public TResult append(java.nio.ByteBuffer table, TAppend tappend) throws TIOError, org.apache.thrift.TException
+ {
+ send_append(table, tappend);
+ return recv_append();
+ }
+
+ public void send_append(java.nio.ByteBuffer table, TAppend tappend) throws org.apache.thrift.TException
+ {
+ append_args args = new append_args();
+ args.setTable(table);
+ args.setTappend(tappend);
+ sendBase("append", args);
+ }
+
+ public TResult recv_append() throws TIOError, org.apache.thrift.TException
+ {
+ append_result result = new append_result();
+ receiveBase(result, "append");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "append failed: unknown result");
+ }
+
+ public int openScanner(java.nio.ByteBuffer table, TScan tscan) throws TIOError, org.apache.thrift.TException
+ {
+ send_openScanner(table, tscan);
+ return recv_openScanner();
+ }
+
+ public void send_openScanner(java.nio.ByteBuffer table, TScan tscan) throws org.apache.thrift.TException
+ {
+ openScanner_args args = new openScanner_args();
+ args.setTable(table);
+ args.setTscan(tscan);
+ sendBase("openScanner", args);
+ }
+
+ public int recv_openScanner() throws TIOError, org.apache.thrift.TException
+ {
+ openScanner_result result = new openScanner_result();
+ receiveBase(result, "openScanner");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
+ }
+
+ public java.util.List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException
+ {
+ send_getScannerRows(scannerId, numRows);
+ return recv_getScannerRows();
+ }
+
+ public void send_getScannerRows(int scannerId, int numRows) throws org.apache.thrift.TException
+ {
+ getScannerRows_args args = new getScannerRows_args();
+ args.setScannerId(scannerId);
+ args.setNumRows(numRows);
+ sendBase("getScannerRows", args);
+ }
+
+ public java.util.List<TResult> recv_getScannerRows() throws TIOError, TIllegalArgument, org.apache.thrift.TException
+ {
+ getScannerRows_result result = new getScannerRows_result();
+ receiveBase(result, "getScannerRows");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
+ }
+
+ public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException
+ {
+ send_closeScanner(scannerId);
+ recv_closeScanner();
+ }
+
+ public void send_closeScanner(int scannerId) throws org.apache.thrift.TException
+ {
+ closeScanner_args args = new closeScanner_args();
+ args.setScannerId(scannerId);
+ sendBase("closeScanner", args);
+ }
+
+ public void recv_closeScanner() throws TIOError, TIllegalArgument, org.apache.thrift.TException
+ {
+ closeScanner_result result = new closeScanner_result();
+ receiveBase(result, "closeScanner");
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ return;
+ }
+
+ public void mutateRow(java.nio.ByteBuffer table, TRowMutations trowMutations) throws TIOError, org.apache.thrift.TException
+ {
+ send_mutateRow(table, trowMutations);
+ recv_mutateRow();
+ }
+
+ public void send_mutateRow(java.nio.ByteBuffer table, TRowMutations trowMutations) throws org.apache.thrift.TException
+ {
+ mutateRow_args args = new mutateRow_args();
+ args.setTable(table);
+ args.setTrowMutations(trowMutations);
+ sendBase("mutateRow", args);
+ }
+
+ public void recv_mutateRow() throws TIOError, org.apache.thrift.TException
+ {
+ mutateRow_result result = new mutateRow_result();
+ receiveBase(result, "mutateRow");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public java.util.List<TResult> getScannerResults(java.nio.ByteBuffer table, TScan tscan, int numRows) throws TIOError, org.apache.thrift.TException
+ {
+ send_getScannerResults(table, tscan, numRows);
+ return recv_getScannerResults();
+ }
+
+ public void send_getScannerResults(java.nio.ByteBuffer table, TScan tscan, int numRows) throws org.apache.thrift.TException
+ {
+ getScannerResults_args args = new getScannerResults_args();
+ args.setTable(table);
+ args.setTscan(tscan);
+ args.setNumRows(numRows);
+ sendBase("getScannerResults", args);
+ }
+
+ public java.util.List<TResult> recv_getScannerResults() throws TIOError, org.apache.thrift.TException
+ {
+ getScannerResults_result result = new getScannerResults_result();
+ receiveBase(result, "getScannerResults");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerResults failed: unknown result");
+ }
+
+ public THRegionLocation getRegionLocation(java.nio.ByteBuffer table, java.nio.ByteBuffer row, boolean reload) throws TIOError, org.apache.thrift.TException
+ {
+ send_getRegionLocation(table, row, reload);
+ return recv_getRegionLocation();
+ }
+
+ public void send_getRegionLocation(java.nio.ByteBuffer table, java.nio.ByteBuffer row, boolean reload) throws org.apache.thrift.TException
+ {
+ getRegionLocation_args args = new getRegionLocation_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setReload(reload);
+ sendBase("getRegionLocation", args);
+ }
+
+ public THRegionLocation recv_getRegionLocation() throws TIOError, org.apache.thrift.TException
+ {
+ getRegionLocation_result result = new getRegionLocation_result();
+ receiveBase(result, "getRegionLocation");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRegionLocation failed: unknown result");
+ }
+
+ public java.util.List<THRegionLocation> getAllRegionLocations(java.nio.ByteBuffer table) throws TIOError, org.apache.thrift.TException
+ {
+ send_getAllRegionLocations(table);
+ return recv_getAllRegionLocations();
+ }
+
+ public void send_getAllRegionLocations(java.nio.ByteBuffer table) throws org.apache.thrift.TException
+ {
+ getAllRegionLocations_args args = new getAllRegionLocations_args();
+ args.setTable(table);
+ sendBase("getAllRegionLocations", args);
+ }
+
+ public java.util.List<THRegionLocation> recv_getAllRegionLocations() throws TIOError, org.apache.thrift.TException
+ {
+ getAllRegionLocations_result result = new getAllRegionLocations_result();
+ receiveBase(result, "getAllRegionLocations");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllRegionLocations failed: unknown result");
+ }
+
+ public boolean checkAndMutate(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, TCompareOperator compareOperator, java.nio.ByteBuffer value, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException
+ {
+ send_checkAndMutate(table, row, family, qualifier, compareOperator, value, rowMutations);
+ return recv_checkAndMutate();
+ }
+
+ public void send_checkAndMutate(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, TCompareOperator compareOperator, java.nio.ByteBuffer value, TRowMutations rowMutations) throws org.apache.thrift.TException
+ {
+ checkAndMutate_args args = new checkAndMutate_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setFamily(family);
+ args.setQualifier(qualifier);
+ args.setCompareOperator(compareOperator);
+ args.setValue(value);
+ args.setRowMutations(rowMutations);
+ sendBase("checkAndMutate", args);
+ }
+
+ public boolean recv_checkAndMutate() throws TIOError, org.apache.thrift.TException
+ {
+ checkAndMutate_result result = new checkAndMutate_result();
+ receiveBase(result, "checkAndMutate");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndMutate failed: unknown result");
+ }
+
+ public TTableDescriptor getTableDescriptor(TTableName table) throws TIOError, org.apache.thrift.TException
+ {
+ send_getTableDescriptor(table);
+ return recv_getTableDescriptor();
+ }
+
+ public void send_getTableDescriptor(TTableName table) throws org.apache.thrift.TException
+ {
+ getTableDescriptor_args args = new getTableDescriptor_args();
+ args.setTable(table);
+ sendBase("getTableDescriptor", args);
+ }
+
+ public TTableDescriptor recv_getTableDescriptor() throws TIOError, org.apache.thrift.TException
+ {
+ getTableDescriptor_result result = new getTableDescriptor_result();
+ receiveBase(result, "getTableDescriptor");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableDescriptor failed: unknown result");
+ }
+
+ public java.util.List<TTableDescriptor> getTableDescriptors(java.util.List<TTableName> tables) throws TIOError, org.apache.thrift.TException
+ {
+ send_getTableDescriptors(tables);
+ return recv_getTableDescriptors();
+ }
+
+ public void send_getTableDescriptors(java.util.List<TTableName> tables) throws org.apache.thrift.TException
+ {
+ getTableDescriptors_args args = new getTableDescriptors_args();
+ args.setTables(tables);
+ sendBase("getTableDescriptors", args);
+ }
+
+ public java.util.List<TTableDescriptor> recv_getTableDescriptors() throws TIOError, org.apache.thrift.TException
+ {
+ getTableDescriptors_result result = new getTableDescriptors_result();
+ receiveBase(result, "getTableDescriptors");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableDescriptors failed: unknown result");
+ }
+
+ public boolean tableExists(TTableName tableName) throws TIOError, org.apache.thrift.TException
+ {
+ send_tableExists(tableName);
+ return recv_tableExists();
+ }
+
+ public void send_tableExists(TTableName tableName) throws org.apache.thrift.TException
+ {
+ tableExists_args args = new tableExists_args();
+ args.setTableName(tableName);
+ sendBase("tableExists", args);
+ }
+
+ public boolean recv_tableExists() throws TIOError, org.apache.thrift.TException
+ {
+ tableExists_result result = new tableExists_result();
+ receiveBase(result, "tableExists");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "tableExists failed: unknown result");
+ }
+
+ public java.util.List<TTableDescriptor> getTableDescriptorsByPattern(java.lang.String regex, boolean includeSysTables) throws TIOError, org.apache.thrift.TException
+ {
+ send_getTableDescriptorsByPattern(regex, includeSysTables);
+ return recv_getTableDescriptorsByPattern();
+ }
+
+ public void send_getTableDescriptorsByPattern(java.lang.String regex, boolean includeSysTables) throws org.apache.thrift.TException
+ {
+ getTableDescriptorsByPattern_args args = new getTableDescriptorsByPattern_args();
+ args.setRegex(regex);
+ args.setIncludeSysTables(includeSysTables);
+ sendBase("getTableDescriptorsByPattern", args);
+ }
+
+ public java.util.List<TTableDescriptor> recv_getTableDescriptorsByPattern() throws TIOError, org.apache.thrift.TException
+ {
+ getTableDescriptorsByPattern_result result = new getTableDescriptorsByPattern_result();
+ receiveBase(result, "getTableDescriptorsByPattern");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableDescriptorsByPattern failed: unknown result");
+ }
+
+ public java.util.List<TTableDescriptor> getTableDescriptorsByNamespace(java.lang.String name) throws TIOError, org.apache.thrift.TException
+ {
+ send_getTableDescriptorsByNamespace(name);
+ return recv_getTableDescriptorsByNamespace();
+ }
+
+ public void send_getTableDescriptorsByNamespace(java.lang.String name) throws org.apache.thrift.TException
+ {
+ getTableDescriptorsByNamespace_args args = new getTableDescriptorsByNamespace_args();
+ args.setName(name);
+ sendBase("getTableDescriptorsByNamespace", args);
+ }
+
+ public java.util.List<TTableDescriptor> recv_getTableDescriptorsByNamespace() throws TIOError, org.apache.thrift.TException
+ {
+ getTableDescriptorsByNamespace_result result = new getTableDescriptorsByNamespace_result();
+ receiveBase(result, "getTableDescriptorsByNamespace");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableDescriptorsByNamespace failed: unknown result");
+ }
+
+ public java.util.List<TTableName> getTableNamesByPattern(java.lang.String regex, boolean includeSysTables) throws TIOError, org.apache.thrift.TException
+ {
+ send_getTableNamesByPattern(regex, includeSysTables);
+ return recv_getTableNamesByPattern();
+ }
+
+ public void send_getTableNamesByPattern(java.lang.String regex, boolean includeSysTables) throws org.apache.thrift.TException
+ {
+ getTableNamesByPattern_args args = new getTableNamesByPattern_args();
+ args.setRegex(regex);
+ args.setIncludeSysTables(includeSysTables);
+ sendBase("getTableNamesByPattern", args);
+ }
+
+ public java.util.List<TTableName> recv_getTableNamesByPattern() throws TIOError, org.apache.thrift.TException
+ {
+ getTableNamesByPattern_result result = new getTableNamesByPattern_result();
+ receiveBase(result, "getTableNamesByPattern");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableNamesByPattern failed: unknown result");
+ }
+
+ public java.util.List<TTableName> getTableNamesByNamespace(java.lang.String name) throws TIOError, org.apache.thrift.TException
+ {
+ send_getTableNamesByNamespace(name);
+ return recv_getTableNamesByNamespace();
+ }
+
+ public void send_getTableNamesByNamespace(java.lang.String name) throws org.apache.thrift.TException
+ {
+ getTableNamesByNamespace_args args = new getTableNamesByNamespace_args();
+ args.setName(name);
+ sendBase("getTableNamesByNamespace", args);
+ }
+
+ public java.util.List<TTableName> recv_getTableNamesByNamespace() throws TIOError, org.apache.thrift.TException
+ {
+ getTableNamesByNamespace_result result = new getTableNamesByNamespace_result();
+ receiveBase(result, "getTableNamesByNamespace");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getTableNamesByNamespace failed: unknown result");
+ }
+
+ public void createTable(TTableDescriptor desc, java.util.List<java.nio.ByteBuffer> splitKeys) throws TIOError, org.apache.thrift.TException
+ {
+ send_createTable(desc, splitKeys);
+ recv_createTable();
+ }
+
+ public void send_createTable(TTableDescriptor desc, java.util.List<java.nio.ByteBuffer> splitKeys) throws org.apache.thrift.TException
+ {
+ createTable_args args = new createTable_args();
+ args.setDesc(desc);
+ args.setSplitKeys(splitKeys);
+ sendBase("createTable", args);
+ }
+
+ public void recv_createTable() throws TIOError, org.apache.thrift.TException
+ {
+ createTable_result result = new createTable_result();
+ receiveBase(result, "createTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void deleteTable(TTableName tableName) throws TIOError, org.apache.thrift.TException
+ {
+ send_deleteTable(tableName);
+ recv_deleteTable();
+ }
+
+ public void send_deleteTable(TTableName tableName) throws org.apache.thrift.TException
+ {
+ deleteTable_args args = new deleteTable_args();
+ args.setTableName(tableName);
+ sendBase("deleteTable", args);
+ }
+
+ public void recv_deleteTable() throws TIOError, org.apache.thrift.TException
+ {
+ deleteTable_result result = new deleteTable_result();
+ receiveBase(result, "deleteTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void truncateTable(TTableName tableName, boolean preserveSplits) throws TIOError, org.apache.thrift.TException
+ {
+ send_truncateTable(tableName, preserveSplits);
+ recv_truncateTable();
+ }
+
+ public void send_truncateTable(TTableName tableName, boolean preserveSplits) throws org.apache.thrift.TException
+ {
+ truncateTable_args args = new truncateTable_args();
+ args.setTableName(tableName);
+ args.setPreserveSplits(preserveSplits);
+ sendBase("truncateTable", args);
+ }
+
+ public void recv_truncateTable() throws TIOError, org.apache.thrift.TException
+ {
+ truncateTable_result result = new truncateTable_result();
+ receiveBase(result, "truncateTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void enableTable(TTableName tableName) throws TIOError, org.apache.thrift.TException
+ {
+ send_enableTable(tableName);
+ recv_enableTable();
+ }
+
+ public void send_enableTable(TTableName tableName) throws org.apache.thrift.TException
+ {
+ enableTable_args args = new enableTable_args();
+ args.setTableName(tableName);
+ sendBase("enableTable", args);
+ }
+
+ public void recv_enableTable() throws TIOError, org.apache.thrift.TException
+ {
+ enableTable_result result = new enableTable_result();
+ receiveBase(result, "enableTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void disableTable(TTableName tableName) throws TIOError, org.apache.thrift.TException
+ {
+ send_disableTable(tableName);
+ recv_disableTable();
+ }
+
+ public void send_disableTable(TTableName tableName) throws org.apache.thrift.TException
+ {
+ disableTable_args args = new disableTable_args();
+ args.setTableName(tableName);
+ sendBase("disableTable", args);
+ }
+
+ public void recv_disableTable() throws TIOError, org.apache.thrift.TException
+ {
+ disableTable_result result = new disableTable_result();
+ receiveBase(result, "disableTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public boolean isTableEnabled(TTableName tableName) throws TIOError, org.apache.thrift.TException
+ {
+ send_isTableEnabled(tableName);
+ return recv_isTableEnabled();
+ }
+
+ public void send_isTableEnabled(TTableName tableName) throws org.apache.thrift.TException
+ {
+ isTableEnabled_args args = new isTableEnabled_args();
+ args.setTableName(tableName);
+ sendBase("isTableEnabled", args);
+ }
+
+ public boolean recv_isTableEnabled() throws TIOError, org.apache.thrift.TException
+ {
+ isTableEnabled_result result = new isTableEnabled_result();
+ receiveBase(result, "isTableEnabled");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
+ }
+
+ public boolean isTableDisabled(TTableName tableName) throws TIOError, org.apache.thrift.TException
+ {
+ send_isTableDisabled(tableName);
+ return recv_isTableDisabled();
+ }
+
+ public void send_isTableDisabled(TTableName tableName) throws org.apache.thrift.TException
+ {
+ isTableDisabled_args args = new isTableDisabled_args();
+ args.setTableName(tableName);
+ sendBase("isTableDisabled", args);
+ }
+
+ public boolean recv_isTableDisabled() throws TIOError, org.apache.thrift.TException
+ {
+ isTableDisabled_result result = new isTableDisabled_result();
+ receiveBase(result, "isTableDisabled");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTableDisabled failed: unknown result");
+ }
+
+ public boolean isTableAvailable(TTableName tableName) throws TIOError, org.apache.thrift.TException
+ {
+ send_isTableAvailable(tableName);
+ return recv_isTableAvailable();
+ }
+
+ public void send_isTableAvailable(TTableName tableName) throws org.apache.thrift.TException
+ {
+ isTableAvailable_args args = new isTableAvailable_args();
+ args.setTableName(tableName);
+ sendBase("isTableAvailable", args);
+ }
+
+ public boolean recv_isTableAvailable() throws TIOError, org.apache.thrift.TException
+ {
+ isTableAvailable_result result = new isTableAvailable_result();
+ receiveBase(result, "isTableAvailable");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTableAvailable failed: unknown result");
+ }
+
+ public boolean isTableAvailableWithSplit(TTableName tableName, java.util.List<java.nio.ByteBuffer> splitKeys) throws TIOError, org.apache.thrift.TException
+ {
+ send_isTableAvailableWithSplit(tableName, splitKeys);
+ return recv_isTableAvailableWithSplit();
+ }
+
+ public void send_isTableAvailableWithSplit(TTableName tableName, java.util.List<java.nio.ByteBuffer> splitKeys) throws org.apache.thrift.TException
+ {
+ isTableAvailableWithSplit_args args = new isTableAvailableWithSplit_args();
+ args.setTableName(tableName);
+ args.setSplitKeys(splitKeys);
+ sendBase("isTableAvailableWithSplit", args);
+ }
+
+ public boolean recv_isTableAvailableWithSplit() throws TIOError, org.apache.thrift.TException
+ {
+ isTableAvailableWithSplit_result result = new isTableAvailableWithSplit_result();
+ receiveBase(result, "isTableAvailableWithSplit");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTableAvailableWithSplit failed: unknown result");
+ }
+
+ public void addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws TIOError, org.apache.thrift.TException
+ {
+ send_addColumnFamily(tableName, column);
+ recv_addColumnFamily();
+ }
+
+ public void send_addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws org.apache.thrift.TException
+ {
+ addColumnFamily_args args = new addColumnFamily_args();
+ args.setTableName(tableName);
+ args.setColumn(column);
+ sendBase("addColumnFamily", args);
+ }
+
+ public void recv_addColumnFamily() throws TIOError, org.apache.thrift.TException
+ {
+ addColumnFamily_result result = new addColumnFamily_result();
+ receiveBase(result, "addColumnFamily");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void deleteColumnFamily(TTableName tableName, java.nio.ByteBuffer column) throws TIOError, org.apache.thrift.TException
+ {
+ send_deleteColumnFamily(tableName, column);
+ recv_deleteColumnFamily();
+ }
+
+ public void send_deleteColumnFamily(TTableName tableName, java.nio.ByteBuffer column) throws org.apache.thrift.TException
+ {
+ deleteColumnFamily_args args = new deleteColumnFamily_args();
+ args.setTableName(tableName);
+ args.setColumn(column);
+ sendBase("deleteColumnFamily", args);
+ }
+
+ public void recv_deleteColumnFamily() throws TIOError, org.apache.thrift.TException
+ {
+ deleteColumnFamily_result result = new deleteColumnFamily_result();
+ receiveBase(result, "deleteColumnFamily");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws TIOError, org.apache.thrift.TException
+ {
+ send_modifyColumnFamily(tableName, column);
+ recv_modifyColumnFamily();
+ }
+
+ public void send_modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws org.apache.thrift.TException
+ {
+ modifyColumnFamily_args args = new modifyColumnFamily_args();
+ args.setTableName(tableName);
+ args.setColumn(column);
+ sendBase("modifyColumnFamily", args);
+ }
+
+ public void recv_modifyColumnFamily() throws TIOError, org.apache.thrift.TException
+ {
+ modifyColumnFamily_result result = new modifyColumnFamily_result();
+ receiveBase(result, "modifyColumnFamily");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void modifyTable(TTableDescriptor desc) throws TIOError, org.apache.thrift.TException
+ {
+ send_modifyTable(desc);
+ recv_modifyTable();
+ }
+
+ public void send_modifyTable(TTableDescriptor desc) throws org.apache.thrift.TException
+ {
+ modifyTable_args args = new modifyTable_args();
+ args.setDesc(desc);
+ sendBase("modifyTable", args);
+ }
+
+ public void recv_modifyTable() throws TIOError, org.apache.thrift.TException
+ {
+ modifyTable_result result = new modifyTable_result();
+ receiveBase(result, "modifyTable");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void createNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, org.apache.thrift.TException
+ {
+ send_createNamespace(namespaceDesc);
+ recv_createNamespace();
+ }
+
+ public void send_createNamespace(TNamespaceDescriptor namespaceDesc) throws org.apache.thrift.TException
+ {
+ createNamespace_args args = new createNamespace_args();
+ args.setNamespaceDesc(namespaceDesc);
+ sendBase("createNamespace", args);
+ }
+
+ public void recv_createNamespace() throws TIOError, org.apache.thrift.TException
+ {
+ createNamespace_result result = new createNamespace_result();
+ receiveBase(result, "createNamespace");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void modifyNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, org.apache.thrift.TException
+ {
+ send_modifyNamespace(namespaceDesc);
+ recv_modifyNamespace();
+ }
+
+ public void send_modifyNamespace(TNamespaceDescriptor namespaceDesc) throws org.apache.thrift.TException
+ {
+ modifyNamespace_args args = new modifyNamespace_args();
+ args.setNamespaceDesc(namespaceDesc);
+ sendBase("modifyNamespace", args);
+ }
+
+ public void recv_modifyNamespace() throws TIOError, org.apache.thrift.TException
+ {
+ modifyNamespace_result result = new modifyNamespace_result();
+ receiveBase(result, "modifyNamespace");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public void deleteNamespace(java.lang.String name) throws TIOError, org.apache.thrift.TException
+ {
+ send_deleteNamespace(name);
+ recv_deleteNamespace();
+ }
+
+ public void send_deleteNamespace(java.lang.String name) throws org.apache.thrift.TException
+ {
+ deleteNamespace_args args = new deleteNamespace_args();
+ args.setName(name);
+ sendBase("deleteNamespace", args);
+ }
+
+ public void recv_deleteNamespace() throws TIOError, org.apache.thrift.TException
+ {
+ deleteNamespace_result result = new deleteNamespace_result();
+ receiveBase(result, "deleteNamespace");
+ if (result.io != null) {
+ throw result.io;
+ }
+ return;
+ }
+
+ public TNamespaceDescriptor getNamespaceDescriptor(java.lang.String name) throws TIOError, org.apache.thrift.TException
+ {
+ send_getNamespaceDescriptor(name);
+ return recv_getNamespaceDescriptor();
+ }
+
+ public void send_getNamespaceDescriptor(java.lang.String name) throws org.apache.thrift.TException
+ {
+ getNamespaceDescriptor_args args = new getNamespaceDescriptor_args();
+ args.setName(name);
+ sendBase("getNamespaceDescriptor", args);
+ }
+
+ public TNamespaceDescriptor recv_getNamespaceDescriptor() throws TIOError, org.apache.thrift.TException
+ {
+ getNamespaceDescriptor_result result = new getNamespaceDescriptor_result();
+ receiveBase(result, "getNamespaceDescriptor");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getNamespaceDescriptor failed: unknown result");
+ }
+
+ public java.util.List<TNamespaceDescriptor> listNamespaceDescriptors() throws TIOError, org.apache.thrift.TException
+ {
+ send_listNamespaceDescriptors();
+ return recv_listNamespaceDescriptors();
+ }
+
+ public void send_listNamespaceDescriptors() throws org.apache.thrift.TException
+ {
+ listNamespaceDescriptors_args args = new listNamespaceDescriptors_args();
+ sendBase("listNamespaceDescriptors", args);
+ }
+
+ public java.util.List<TNamespaceDescriptor> recv_listNamespaceDescriptors() throws TIOError, org.apache.thrift.TException
+ {
+ listNamespaceDescriptors_result result = new listNamespaceDescriptors_result();
+ receiveBase(result, "listNamespaceDescriptors");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "listNamespaceDescriptors failed: unknown result");
+ }
+
+ public java.util.List<java.lang.String> listNamespaces() throws TIOError, org.apache.thrift.TException
+ {
+ send_listNamespaces();
+ return recv_listNamespaces();
+ }
+
+ public void send_listNamespaces() throws org.apache.thrift.TException
+ {
+ listNamespaces_args args = new listNamespaces_args();
+ sendBase("listNamespaces", args);
+ }
+
+ public java.util.List<java.lang.String> recv_listNamespaces() throws TIOError, org.apache.thrift.TException
+ {
+ listNamespaces_result result = new listNamespaces_result();
+ receiveBase(result, "listNamespaces");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "listNamespaces failed: unknown result");
+ }
+
+ public TThriftServerType getThriftServerType() throws org.apache.thrift.TException
+ {
+ send_getThriftServerType();
+ return recv_getThriftServerType();
+ }
+
+ public void send_getThriftServerType() throws org.apache.thrift.TException
+ {
+ getThriftServerType_args args = new getThriftServerType_args();
+ sendBase("getThriftServerType", args);
+ }
+
+ public TThriftServerType recv_getThriftServerType() throws org.apache.thrift.TException
+ {
+ getThriftServerType_result result = new getThriftServerType_result();
+ receiveBase(result, "getThriftServerType");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getThriftServerType failed: unknown result");
+ }
+
+ public java.lang.String getClusterId() throws org.apache.thrift.TException
+ {
+ send_getClusterId();
+ return recv_getClusterId();
+ }
+
+ public void send_getClusterId() throws org.apache.thrift.TException
+ {
+ getClusterId_args args = new getClusterId_args();
+ sendBase("getClusterId", args);
+ }
+
+ public java.lang.String recv_getClusterId() throws org.apache.thrift.TException
+ {
+ getClusterId_result result = new getClusterId_result();
+ receiveBase(result, "getClusterId");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getClusterId failed: unknown result");
+ }
+
+ public java.util.List<TOnlineLogRecord> getSlowLogResponses(java.util.Set<TServerName> serverNames, TLogQueryFilter logQueryFilter) throws TIOError, org.apache.thrift.TException
+ {
+ send_getSlowLogResponses(serverNames, logQueryFilter);
+ return recv_getSlowLogResponses();
+ }
+
+ public void send_getSlowLogResponses(java.util.Set<TServerName> serverNames, TLogQueryFilter logQueryFilter) throws org.apache.thrift.TException
+ {
+ getSlowLogResponses_args args = new getSlowLogResponses_args();
+ args.setServerNames(serverNames);
+ args.setLogQueryFilter(logQueryFilter);
+ sendBase("getSlowLogResponses", args);
+ }
+
+ public java.util.List<TOnlineLogRecord> recv_getSlowLogResponses() throws TIOError, org.apache.thrift.TException
+ {
+ getSlowLogResponses_result result = new getSlowLogResponses_result();
+ receiveBase(result, "getSlowLogResponses");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getSlowLogResponses failed: unknown result");
+ }
+
+ public java.util.List<java.lang.Boolean> clearSlowLogResponses(java.util.Set<TServerName> serverNames) throws TIOError, org.apache.thrift.TException
+ {
+ send_clearSlowLogResponses(serverNames);
+ return recv_clearSlowLogResponses();
+ }
+
+ public void send_clearSlowLogResponses(java.util.Set<TServerName> serverNames) throws org.apache.thrift.TException
+ {
+ clearSlowLogResponses_args args = new clearSlowLogResponses_args();
+ args.setServerNames(serverNames);
+ sendBase("clearSlowLogResponses", args);
+ }
+
+ public java.util.List<java.lang.Boolean> recv_clearSlowLogResponses() throws TIOError, org.apache.thrift.TException
+ {
+ clearSlowLogResponses_result result = new clearSlowLogResponses_result();
+ receiveBase(result, "clearSlowLogResponses");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "clearSlowLogResponses failed: unknown result");
+ }
+
+ public boolean grant(TAccessControlEntity info) throws TIOError, org.apache.thrift.TException
+ {
+ send_grant(info);
+ return recv_grant();
+ }
+
+ public void send_grant(TAccessControlEntity info) throws org.apache.thrift.TException
+ {
+ grant_args args = new grant_args();
+ args.setInfo(info);
+ sendBase("grant", args);
+ }
+
+ public boolean recv_grant() throws TIOError, org.apache.thrift.TException
+ {
+ grant_result result = new grant_result();
+ receiveBase(result, "grant");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "grant failed: unknown result");
+ }
+
+ public boolean revoke(TAccessControlEntity info) throws TIOError, org.apache.thrift.TException
+ {
+ send_revoke(info);
+ return recv_revoke();
+ }
+
+ public void send_revoke(TAccessControlEntity info) throws org.apache.thrift.TException
+ {
+ revoke_args args = new revoke_args();
+ args.setInfo(info);
+ sendBase("revoke", args);
+ }
+
+ public boolean recv_revoke() throws TIOError, org.apache.thrift.TException
+ {
+ revoke_result result = new revoke_result();
+ receiveBase(result, "revoke");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "revoke failed: unknown result");
+ }
+
+ }
+ public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
+ public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
+ 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) {
+ this.clientManager = clientManager;
+ this.protocolFactory = protocolFactory;
+ }
+ public AsyncClient getAsyncClient(org.apache.thrift.transport.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) {
+ super(protocolFactory, clientManager, transport);
+ }
+
+ public void exists(java.nio.ByteBuffer table, TGet tget, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ exists_call method_call = new exists_call(table, tget, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class exists_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private java.nio.ByteBuffer table;
+ private TGet tget;
+ public exists_call(java.nio.ByteBuffer table, TGet tget, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tget = tget;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exists", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ exists_args args = new exists_args();
+ args.setTable(table);
+ args.setTget(tget);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_exists();
+ }
+ }
+
+ public void existsAll(java.nio.ByteBuffer table, java.util.List<TGet> tgets, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ existsAll_call method_call = new existsAll_call(table, tgets, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class existsAll_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<java.lang.Boolean>> {
+ private java.nio.ByteBuffer table;
+ private java.util.List<TGet> tgets;
+ public existsAll_call(java.nio.ByteBuffer table, java.util.List<TGet> tgets, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tgets = tgets;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("existsAll", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ existsAll_args args = new existsAll_args();
+ args.setTable(table);
+ args.setTgets(tgets);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<java.lang.Boolean> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_existsAll();
+ }
+ }
+
+ public void get(java.nio.ByteBuffer table, TGet tget, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ get_call method_call = new get_call(table, tget, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class get_call extends org.apache.thrift.async.TAsyncMethodCall<TResult> {
+ private java.nio.ByteBuffer table;
+ private TGet tget;
+ public get_call(java.nio.ByteBuffer table, TGet tget, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tget = tget;
+ }
+
+ 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));
+ get_args args = new get_args();
+ args.setTable(table);
+ args.setTget(tget);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TResult getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_get();
+ }
+ }
+
+ public void getMultiple(java.nio.ByteBuffer table, java.util.List<TGet> tgets, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getMultiple_call method_call = new getMultiple_call(table, tgets, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getMultiple_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TResult>> {
+ private java.nio.ByteBuffer table;
+ private java.util.List<TGet> tgets;
+ public getMultiple_call(java.nio.ByteBuffer table, java.util.List<TGet> tgets, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tgets = tgets;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getMultiple_args args = new getMultiple_args();
+ args.setTable(table);
+ args.setTgets(tgets);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getMultiple();
+ }
+ }
+
+ public void put(java.nio.ByteBuffer table, TPut tput, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ put_call method_call = new put_call(table, tput, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class put_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer table;
+ private TPut tput;
+ public put_call(java.nio.ByteBuffer table, TPut tput, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tput = tput;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("put", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ put_args args = new put_args();
+ args.setTable(table);
+ args.setTput(tput);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void checkAndPut(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TPut tput, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ checkAndPut_call method_call = new checkAndPut_call(table, row, family, qualifier, value, tput, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private java.nio.ByteBuffer table;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer family;
+ private java.nio.ByteBuffer qualifier;
+ private java.nio.ByteBuffer value;
+ private TPut tput;
+ public checkAndPut_call(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TPut tput, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.row = row;
+ this.family = family;
+ this.qualifier = qualifier;
+ this.value = value;
+ this.tput = tput;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ checkAndPut_args args = new checkAndPut_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setFamily(family);
+ args.setQualifier(qualifier);
+ args.setValue(value);
+ args.setTput(tput);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_checkAndPut();
+ }
+ }
+
+ public void putMultiple(java.nio.ByteBuffer table, java.util.List<TPut> tputs, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ putMultiple_call method_call = new putMultiple_call(table, tputs, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class putMultiple_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer table;
+ private java.util.List<TPut> tputs;
+ public putMultiple_call(java.nio.ByteBuffer table, java.util.List<TPut> tputs, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tputs = tputs;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("putMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ putMultiple_args args = new putMultiple_args();
+ args.setTable(table);
+ args.setTputs(tputs);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteSingle(java.nio.ByteBuffer table, TDelete tdelete, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteSingle_call method_call = new deleteSingle_call(table, tdelete, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteSingle_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer table;
+ private TDelete tdelete;
+ public deleteSingle_call(java.nio.ByteBuffer table, TDelete tdelete, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tdelete = tdelete;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteSingle", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ deleteSingle_args args = new deleteSingle_args();
+ args.setTable(table);
+ args.setTdelete(tdelete);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteMultiple(java.nio.ByteBuffer table, java.util.List<TDelete> tdeletes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TDelete>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteMultiple_call method_call = new deleteMultiple_call(table, tdeletes, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteMultiple_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TDelete>> {
+ private java.nio.ByteBuffer table;
+ private java.util.List<TDelete> tdeletes;
+ public deleteMultiple_call(java.nio.ByteBuffer table, java.util.List<TDelete> tdeletes, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TDelete>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tdeletes = tdeletes;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ deleteMultiple_args args = new deleteMultiple_args();
+ args.setTable(table);
+ args.setTdeletes(tdeletes);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TDelete> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_deleteMultiple();
+ }
+ }
+
+ public void checkAndDelete(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TDelete tdelete, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ checkAndDelete_call method_call = new checkAndDelete_call(table, row, family, qualifier, value, tdelete, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class checkAndDelete_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private java.nio.ByteBuffer table;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer family;
+ private java.nio.ByteBuffer qualifier;
+ private java.nio.ByteBuffer value;
+ private TDelete tdelete;
+ public checkAndDelete_call(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, java.nio.ByteBuffer value, TDelete tdelete, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.row = row;
+ this.family = family;
+ this.qualifier = qualifier;
+ this.value = value;
+ this.tdelete = tdelete;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndDelete", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ checkAndDelete_args args = new checkAndDelete_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setFamily(family);
+ args.setQualifier(qualifier);
+ args.setValue(value);
+ args.setTdelete(tdelete);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_checkAndDelete();
+ }
+ }
+
+ public void increment(java.nio.ByteBuffer table, TIncrement tincrement, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ increment_call method_call = new increment_call(table, tincrement, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall<TResult> {
+ private java.nio.ByteBuffer table;
+ private TIncrement tincrement;
+ public increment_call(java.nio.ByteBuffer table, TIncrement tincrement, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tincrement = tincrement;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ increment_args args = new increment_args();
+ args.setTable(table);
+ args.setTincrement(tincrement);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TResult getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_increment();
+ }
+ }
+
+ public void append(java.nio.ByteBuffer table, TAppend tappend, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ append_call method_call = new append_call(table, tappend, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class append_call extends org.apache.thrift.async.TAsyncMethodCall<TResult> {
+ private java.nio.ByteBuffer table;
+ private TAppend tappend;
+ public append_call(java.nio.ByteBuffer table, TAppend tappend, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tappend = tappend;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("append", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ append_args args = new append_args();
+ args.setTable(table);
+ args.setTappend(tappend);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TResult getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_append();
+ }
+ }
+
+ public void openScanner(java.nio.ByteBuffer table, TScan tscan, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ openScanner_call method_call = new openScanner_call(table, tscan, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class openScanner_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Integer> {
+ private java.nio.ByteBuffer table;
+ private TScan tscan;
+ public openScanner_call(java.nio.ByteBuffer table, TScan tscan, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tscan = tscan;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("openScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ openScanner_args args = new openScanner_args();
+ args.setTable(table);
+ args.setTscan(tscan);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Integer getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_openScanner();
+ }
+ }
+
+ public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getScannerRows_call method_call = new getScannerRows_call(scannerId, numRows, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getScannerRows_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TResult>> {
+ private int scannerId;
+ private int numRows;
+ public getScannerRows_call(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.scannerId = scannerId;
+ this.numRows = numRows;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getScannerRows_args args = new getScannerRows_args();
+ args.setScannerId(scannerId);
+ args.setNumRows(numRows);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TResult> getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getScannerRows();
+ }
+ }
+
+ public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ closeScanner_call method_call = new closeScanner_call(scannerId, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class closeScanner_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private int scannerId;
+ public closeScanner_call(int scannerId, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.scannerId = scannerId;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ closeScanner_args args = new closeScanner_args();
+ args.setScannerId(scannerId);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void mutateRow(java.nio.ByteBuffer table, TRowMutations trowMutations, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ mutateRow_call method_call = new mutateRow_call(table, trowMutations, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class mutateRow_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.nio.ByteBuffer table;
+ private TRowMutations trowMutations;
+ public mutateRow_call(java.nio.ByteBuffer table, TRowMutations trowMutations, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.trowMutations = trowMutations;
+ }
+
+ 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));
+ mutateRow_args args = new mutateRow_args();
+ args.setTable(table);
+ args.setTrowMutations(trowMutations);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void getScannerResults(java.nio.ByteBuffer table, TScan tscan, int numRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getScannerResults_call method_call = new getScannerResults_call(table, tscan, numRows, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getScannerResults_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TResult>> {
+ private java.nio.ByteBuffer table;
+ private TScan tscan;
+ private int numRows;
+ public getScannerResults_call(java.nio.ByteBuffer table, TScan tscan, int numRows, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.tscan = tscan;
+ this.numRows = numRows;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerResults", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getScannerResults_args args = new getScannerResults_args();
+ args.setTable(table);
+ args.setTscan(tscan);
+ args.setNumRows(numRows);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getScannerResults();
+ }
+ }
+
+ public void getRegionLocation(java.nio.ByteBuffer table, java.nio.ByteBuffer row, boolean reload, org.apache.thrift.async.AsyncMethodCallback<THRegionLocation> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getRegionLocation_call method_call = new getRegionLocation_call(table, row, reload, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getRegionLocation_call extends org.apache.thrift.async.TAsyncMethodCall<THRegionLocation> {
+ private java.nio.ByteBuffer table;
+ private java.nio.ByteBuffer row;
+ private boolean reload;
+ public getRegionLocation_call(java.nio.ByteBuffer table, java.nio.ByteBuffer row, boolean reload, org.apache.thrift.async.AsyncMethodCallback<THRegionLocation> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.row = row;
+ this.reload = reload;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRegionLocation", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getRegionLocation_args args = new getRegionLocation_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setReload(reload);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public THRegionLocation getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getRegionLocation();
+ }
+ }
+
+ public void getAllRegionLocations(java.nio.ByteBuffer table, org.apache.thrift.async.AsyncMethodCallback<java.util.List<THRegionLocation>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getAllRegionLocations_call method_call = new getAllRegionLocations_call(table, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getAllRegionLocations_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<THRegionLocation>> {
+ private java.nio.ByteBuffer table;
+ public getAllRegionLocations_call(java.nio.ByteBuffer table, org.apache.thrift.async.AsyncMethodCallback<java.util.List<THRegionLocation>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAllRegionLocations", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getAllRegionLocations_args args = new getAllRegionLocations_args();
+ args.setTable(table);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<THRegionLocation> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getAllRegionLocations();
+ }
+ }
+
+ public void checkAndMutate(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, TCompareOperator compareOperator, java.nio.ByteBuffer value, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ checkAndMutate_call method_call = new checkAndMutate_call(table, row, family, qualifier, compareOperator, value, rowMutations, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class checkAndMutate_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private java.nio.ByteBuffer table;
+ private java.nio.ByteBuffer row;
+ private java.nio.ByteBuffer family;
+ private java.nio.ByteBuffer qualifier;
+ private TCompareOperator compareOperator;
+ private java.nio.ByteBuffer value;
+ private TRowMutations rowMutations;
+ public checkAndMutate_call(java.nio.ByteBuffer table, java.nio.ByteBuffer row, java.nio.ByteBuffer family, java.nio.ByteBuffer qualifier, TCompareOperator compareOperator, java.nio.ByteBuffer value, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ this.row = row;
+ this.family = family;
+ this.qualifier = qualifier;
+ this.compareOperator = compareOperator;
+ this.value = value;
+ this.rowMutations = rowMutations;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndMutate", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ checkAndMutate_args args = new checkAndMutate_args();
+ args.setTable(table);
+ args.setRow(row);
+ args.setFamily(family);
+ args.setQualifier(qualifier);
+ args.setCompareOperator(compareOperator);
+ args.setValue(value);
+ args.setRowMutations(rowMutations);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_checkAndMutate();
+ }
+ }
+
+ public void getTableDescriptor(TTableName table, org.apache.thrift.async.AsyncMethodCallback<TTableDescriptor> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getTableDescriptor_call method_call = new getTableDescriptor_call(table, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getTableDescriptor_call extends org.apache.thrift.async.TAsyncMethodCall<TTableDescriptor> {
+ private TTableName table;
+ public getTableDescriptor_call(TTableName table, org.apache.thrift.async.AsyncMethodCallback<TTableDescriptor> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.table = table;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableDescriptor", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableDescriptor_args args = new getTableDescriptor_args();
+ args.setTable(table);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TTableDescriptor getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableDescriptor();
+ }
+ }
+
+ public void getTableDescriptors(java.util.List<TTableName> tables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getTableDescriptors_call method_call = new getTableDescriptors_call(tables, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getTableDescriptors_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TTableDescriptor>> {
+ private java.util.List<TTableName> tables;
+ public getTableDescriptors_call(java.util.List<TTableName> tables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tables = tables;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableDescriptors", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableDescriptors_args args = new getTableDescriptors_args();
+ args.setTables(tables);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TTableDescriptor> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableDescriptors();
+ }
+ }
+
+ public void tableExists(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ tableExists_call method_call = new tableExists_call(tableName, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class tableExists_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TTableName tableName;
+ public tableExists_call(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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("tableExists", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ tableExists_args args = new tableExists_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_tableExists();
+ }
+ }
+
+ public void getTableDescriptorsByPattern(java.lang.String regex, boolean includeSysTables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getTableDescriptorsByPattern_call method_call = new getTableDescriptorsByPattern_call(regex, includeSysTables, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getTableDescriptorsByPattern_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TTableDescriptor>> {
+ private java.lang.String regex;
+ private boolean includeSysTables;
+ public getTableDescriptorsByPattern_call(java.lang.String regex, boolean includeSysTables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.regex = regex;
+ this.includeSysTables = includeSysTables;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableDescriptorsByPattern", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableDescriptorsByPattern_args args = new getTableDescriptorsByPattern_args();
+ args.setRegex(regex);
+ args.setIncludeSysTables(includeSysTables);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TTableDescriptor> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableDescriptorsByPattern();
+ }
+ }
+
+ public void getTableDescriptorsByNamespace(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getTableDescriptorsByNamespace_call method_call = new getTableDescriptorsByNamespace_call(name, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getTableDescriptorsByNamespace_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TTableDescriptor>> {
+ private java.lang.String name;
+ public getTableDescriptorsByNamespace_call(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.name = name;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableDescriptorsByNamespace", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableDescriptorsByNamespace_args args = new getTableDescriptorsByNamespace_args();
+ args.setName(name);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TTableDescriptor> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableDescriptorsByNamespace();
+ }
+ }
+
+ public void getTableNamesByPattern(java.lang.String regex, boolean includeSysTables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getTableNamesByPattern_call method_call = new getTableNamesByPattern_call(regex, includeSysTables, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getTableNamesByPattern_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TTableName>> {
+ private java.lang.String regex;
+ private boolean includeSysTables;
+ public getTableNamesByPattern_call(java.lang.String regex, boolean includeSysTables, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.regex = regex;
+ this.includeSysTables = includeSysTables;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNamesByPattern", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableNamesByPattern_args args = new getTableNamesByPattern_args();
+ args.setRegex(regex);
+ args.setIncludeSysTables(includeSysTables);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TTableName> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableNamesByPattern();
+ }
+ }
+
+ public void getTableNamesByNamespace(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getTableNamesByNamespace_call method_call = new getTableNamesByNamespace_call(name, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getTableNamesByNamespace_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TTableName>> {
+ private java.lang.String name;
+ public getTableNamesByNamespace_call(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.name = name;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getTableNamesByNamespace", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getTableNamesByNamespace_args args = new getTableNamesByNamespace_args();
+ args.setName(name);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TTableName> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getTableNamesByNamespace();
+ }
+ }
+
+ public void createTable(TTableDescriptor desc, java.util.List<java.nio.ByteBuffer> splitKeys, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ createTable_call method_call = new createTable_call(desc, splitKeys, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class createTable_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TTableDescriptor desc;
+ private java.util.List<java.nio.ByteBuffer> splitKeys;
+ public createTable_call(TTableDescriptor desc, java.util.List<java.nio.ByteBuffer> splitKeys, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.desc = desc;
+ this.splitKeys = splitKeys;
+ }
+
+ 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));
+ createTable_args args = new createTable_args();
+ args.setDesc(desc);
+ args.setSplitKeys(splitKeys);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteTable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private TTableName tableName;
+ public deleteTable_call(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ deleteTable_args args = new deleteTable_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void truncateTable(TTableName tableName, boolean preserveSplits, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ truncateTable_call method_call = new truncateTable_call(tableName, preserveSplits, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class truncateTable_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TTableName tableName;
+ private boolean preserveSplits;
+ public truncateTable_call(TTableName tableName, boolean preserveSplits, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.preserveSplits = preserveSplits;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("truncateTable", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ truncateTable_args args = new truncateTable_args();
+ args.setTableName(tableName);
+ args.setPreserveSplits(preserveSplits);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void enableTable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private TTableName tableName;
+ public enableTable_call(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ enableTable_args args = new enableTable_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void disableTable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.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<Void> {
+ private TTableName tableName;
+ public disableTable_call(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ disableTable_args args = new disableTable_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void isTableEnabled(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.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<java.lang.Boolean> {
+ private TTableName tableName;
+ public isTableEnabled_call(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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));
+ isTableEnabled_args args = new isTableEnabled_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_isTableEnabled();
+ }
+ }
+
+ public void isTableDisabled(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ isTableDisabled_call method_call = new isTableDisabled_call(tableName, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class isTableDisabled_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TTableName tableName;
+ public isTableDisabled_call(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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("isTableDisabled", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ isTableDisabled_args args = new isTableDisabled_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_isTableDisabled();
+ }
+ }
+
+ public void isTableAvailable(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ isTableAvailable_call method_call = new isTableAvailable_call(tableName, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class isTableAvailable_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TTableName tableName;
+ public isTableAvailable_call(TTableName tableName, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.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("isTableAvailable", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ isTableAvailable_args args = new isTableAvailable_args();
+ args.setTableName(tableName);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_isTableAvailable();
+ }
+ }
+
+ public void isTableAvailableWithSplit(TTableName tableName, java.util.List<java.nio.ByteBuffer> splitKeys, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ isTableAvailableWithSplit_call method_call = new isTableAvailableWithSplit_call(tableName, splitKeys, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class isTableAvailableWithSplit_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TTableName tableName;
+ private java.util.List<java.nio.ByteBuffer> splitKeys;
+ public isTableAvailableWithSplit_call(TTableName tableName, java.util.List<java.nio.ByteBuffer> splitKeys, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ this.splitKeys = splitKeys;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTableAvailableWithSplit", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ isTableAvailableWithSplit_args args = new isTableAvailableWithSplit_args();
+ args.setTableName(tableName);
+ args.setSplitKeys(splitKeys);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_isTableAvailableWithSplit();
+ }
+ }
+
+ public void addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ addColumnFamily_call method_call = new addColumnFamily_call(tableName, column, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class addColumnFamily_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TTableName tableName;
+ private TColumnFamilyDescriptor column;
+ public addColumnFamily_call(TTableName tableName, TColumnFamilyDescriptor column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ 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("addColumnFamily", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ addColumnFamily_args args = new addColumnFamily_args();
+ args.setTableName(tableName);
+ args.setColumn(column);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteColumnFamily(TTableName tableName, java.nio.ByteBuffer column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteColumnFamily_call method_call = new deleteColumnFamily_call(tableName, column, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteColumnFamily_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TTableName tableName;
+ private java.nio.ByteBuffer column;
+ public deleteColumnFamily_call(TTableName tableName, java.nio.ByteBuffer column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ 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("deleteColumnFamily", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ deleteColumnFamily_args args = new deleteColumnFamily_args();
+ args.setTableName(tableName);
+ args.setColumn(column);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ modifyColumnFamily_call method_call = new modifyColumnFamily_call(tableName, column, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class modifyColumnFamily_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TTableName tableName;
+ private TColumnFamilyDescriptor column;
+ public modifyColumnFamily_call(TTableName tableName, TColumnFamilyDescriptor column, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.tableName = tableName;
+ 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("modifyColumnFamily", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ modifyColumnFamily_args args = new modifyColumnFamily_args();
+ args.setTableName(tableName);
+ args.setColumn(column);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void modifyTable(TTableDescriptor desc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ modifyTable_call method_call = new modifyTable_call(desc, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class modifyTable_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TTableDescriptor desc;
+ public modifyTable_call(TTableDescriptor desc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.desc = desc;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("modifyTable", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ modifyTable_args args = new modifyTable_args();
+ args.setDesc(desc);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void createNamespace(TNamespaceDescriptor namespaceDesc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ createNamespace_call method_call = new createNamespace_call(namespaceDesc, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class createNamespace_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TNamespaceDescriptor namespaceDesc;
+ public createNamespace_call(TNamespaceDescriptor namespaceDesc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.namespaceDesc = namespaceDesc;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createNamespace", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ createNamespace_args args = new createNamespace_args();
+ args.setNamespaceDesc(namespaceDesc);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void modifyNamespace(TNamespaceDescriptor namespaceDesc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ modifyNamespace_call method_call = new modifyNamespace_call(namespaceDesc, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class modifyNamespace_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private TNamespaceDescriptor namespaceDesc;
+ public modifyNamespace_call(TNamespaceDescriptor namespaceDesc, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.namespaceDesc = namespaceDesc;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("modifyNamespace", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ modifyNamespace_args args = new modifyNamespace_args();
+ args.setNamespaceDesc(namespaceDesc);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void deleteNamespace(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ deleteNamespace_call method_call = new deleteNamespace_call(name, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class deleteNamespace_call extends org.apache.thrift.async.TAsyncMethodCall<Void> {
+ private java.lang.String name;
+ public deleteNamespace_call(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.name = name;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteNamespace", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ deleteNamespace_args args = new deleteNamespace_args();
+ args.setName(name);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Void getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return null;
+ }
+ }
+
+ public void getNamespaceDescriptor(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<TNamespaceDescriptor> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getNamespaceDescriptor_call method_call = new getNamespaceDescriptor_call(name, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getNamespaceDescriptor_call extends org.apache.thrift.async.TAsyncMethodCall<TNamespaceDescriptor> {
+ private java.lang.String name;
+ public getNamespaceDescriptor_call(java.lang.String name, org.apache.thrift.async.AsyncMethodCallback<TNamespaceDescriptor> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.name = name;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getNamespaceDescriptor", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getNamespaceDescriptor_args args = new getNamespaceDescriptor_args();
+ args.setName(name);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TNamespaceDescriptor getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getNamespaceDescriptor();
+ }
+ }
+
+ public void listNamespaceDescriptors(org.apache.thrift.async.AsyncMethodCallback<java.util.List<TNamespaceDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ listNamespaceDescriptors_call method_call = new listNamespaceDescriptors_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class listNamespaceDescriptors_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TNamespaceDescriptor>> {
+ public listNamespaceDescriptors_call(org.apache.thrift.async.AsyncMethodCallback<java.util.List<TNamespaceDescriptor>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("listNamespaceDescriptors", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ listNamespaceDescriptors_args args = new listNamespaceDescriptors_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TNamespaceDescriptor> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_listNamespaceDescriptors();
+ }
+ }
+
+ public void listNamespaces(org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.String>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ listNamespaces_call method_call = new listNamespaces_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class listNamespaces_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<java.lang.String>> {
+ public listNamespaces_call(org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.String>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("listNamespaces", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ listNamespaces_args args = new listNamespaces_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<java.lang.String> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_listNamespaces();
+ }
+ }
+
+ public void getThriftServerType(org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getThriftServerType_call method_call = new getThriftServerType_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getThriftServerType_call extends org.apache.thrift.async.TAsyncMethodCall<TThriftServerType> {
+ public getThriftServerType_call(org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getThriftServerType", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getThriftServerType_args args = new getThriftServerType_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TThriftServerType getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getThriftServerType();
+ }
+ }
+
+ public void getClusterId(org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getClusterId_call method_call = new getClusterId_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getClusterId_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.String> {
+ public getClusterId_call(org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getClusterId", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getClusterId_args args = new getClusterId_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.String getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getClusterId();
+ }
+ }
+
+ public void getSlowLogResponses(java.util.Set<TServerName> serverNames, TLogQueryFilter logQueryFilter, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TOnlineLogRecord>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ getSlowLogResponses_call method_call = new getSlowLogResponses_call(serverNames, logQueryFilter, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class getSlowLogResponses_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<TOnlineLogRecord>> {
+ private java.util.Set<TServerName> serverNames;
+ private TLogQueryFilter logQueryFilter;
+ public getSlowLogResponses_call(java.util.Set<TServerName> serverNames, TLogQueryFilter logQueryFilter, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TOnlineLogRecord>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.serverNames = serverNames;
+ this.logQueryFilter = logQueryFilter;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getSlowLogResponses", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ getSlowLogResponses_args args = new getSlowLogResponses_args();
+ args.setServerNames(serverNames);
+ args.setLogQueryFilter(logQueryFilter);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<TOnlineLogRecord> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_getSlowLogResponses();
+ }
+ }
+
+ public void clearSlowLogResponses(java.util.Set<TServerName> serverNames, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ clearSlowLogResponses_call method_call = new clearSlowLogResponses_call(serverNames, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class clearSlowLogResponses_call extends org.apache.thrift.async.TAsyncMethodCall<java.util.List<java.lang.Boolean>> {
+ private java.util.Set<TServerName> serverNames;
+ public clearSlowLogResponses_call(java.util.Set<TServerName> serverNames, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.serverNames = serverNames;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("clearSlowLogResponses", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ clearSlowLogResponses_args args = new clearSlowLogResponses_args();
+ args.setServerNames(serverNames);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.util.List<java.lang.Boolean> getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_clearSlowLogResponses();
+ }
+ }
+
+ public void grant(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ grant_call method_call = new grant_call(info, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class grant_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TAccessControlEntity info;
+ public grant_call(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.info = info;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("grant", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ grant_args args = new grant_args();
+ args.setInfo(info);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_grant();
+ }
+ }
+
+ public void revoke(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ revoke_call method_call = new revoke_call(info, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class revoke_call extends org.apache.thrift.async.TAsyncMethodCall<java.lang.Boolean> {
+ private TAccessControlEntity info;
+ public revoke_call(TAccessControlEntity info, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.info = info;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("revoke", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ revoke_args args = new revoke_args();
+ args.setInfo(info);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public java.lang.Boolean getResult() throws TIOError, org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_revoke();
+ }
+ }
+
+ }
+
+ public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
+ private static final org.slf4j.Logger _LOGGER = org.slf4j.LoggerFactory.getLogger(Processor.class.getName());
+ public Processor(I iface) {
+ super(iface, getProcessMap(new java.util.HashMap<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
+ }
+
+ protected Processor(I iface, java.util.Map<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
+ super(iface, getProcessMap(processMap));
+ }
+
+ private static <I extends Iface> java.util.Map<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> getProcessMap(java.util.Map<java.lang.String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
+ processMap.put("exists", new exists());
+ processMap.put("existsAll", new existsAll());
+ processMap.put("get", new get());
+ processMap.put("getMultiple", new getMultiple());
+ processMap.put("put", new put());
+ processMap.put("checkAndPut", new checkAndPut());
+ processMap.put("putMultiple", new putMultiple());
+ processMap.put("deleteSingle", new deleteSingle());
+ processMap.put("deleteMultiple", new deleteMultiple());
+ processMap.put("checkAndDelete", new checkAndDelete());
+ processMap.put("increment", new increment());
+ processMap.put("append", new append());
+ processMap.put("openScanner", new openScanner());
+ processMap.put("getScannerRows", new getScannerRows());
+ processMap.put("closeScanner", new closeScanner());
+ processMap.put("mutateRow", new mutateRow());
+ processMap.put("getScannerResults", new getScannerResults());
+ processMap.put("getRegionLocation", new getRegionLocation());
+ processMap.put("getAllRegionLocations", new getAllRegionLocations());
+ processMap.put("checkAndMutate", new checkAndMutate());
+ processMap.put("getTableDescriptor", new getTableDescriptor());
+ processMap.put("getTableDescriptors", new getTableDescriptors());
+ processMap.put("tableExists", new tableExists());
+ processMap.put("getTableDescriptorsByPattern", new getTableDescriptorsByPattern());
+ processMap.put("getTableDescriptorsByNamespace", new getTableDescriptorsByNamespace());
+ processMap.put("getTableNamesByPattern", new getTableNamesByPattern());
+ processMap.put("getTableNamesByNamespace", new getTableNamesByNamespace());
+ processMap.put("createTable", new createTable());
+ processMap.put("deleteTable", new deleteTable());
+ processMap.put("truncateTable", new truncateTable());
+ processMap.put("enableTable", new enableTable());
+ processMap.put("disableTable", new disableTable());
+ processMap.put("isTableEnabled", new isTableEnabled());
+ processMap.put("isTableDisabled", new isTableDisabled());
+ processMap.put("isTableAvailable", new isTableAvailable());
+ processMap.put("isTableAvailableWithSplit", new isTableAvailableWithSplit());
+ processMap.put("addColumnFamily", new addColumnFamily());
+ processMap.put("deleteColumnFamily", new deleteColumnFamily());
+ processMap.put("modifyColumnFamily", new modifyColumnFamily());
+ processMap.put("modifyTable", new modifyTable());
+ processMap.put("createNamespace", new createNamespace());
+ processMap.put("modifyNamespace", new modifyNamespace());
+ processMap.put("deleteNamespace", new deleteNamespace());
+ processMap.put("getNamespaceDescriptor", new getNamespaceDescriptor());
+ processMap.put("listNamespaceDescriptors", new listNamespaceDescriptors());
+ processMap.put("listNamespaces", new listNamespaces());
+ processMap.put("getThriftServerType", new getThriftServerType());
+ processMap.put("getClusterId", new getClusterId());
+ processMap.put("getSlowLogResponses", new getSlowLogResponses());
+ processMap.put("clearSlowLogResponses", new clearSlowLogResponses());
+ processMap.put("grant", new grant());
+ processMap.put("revoke", new revoke());
+ return processMap;
+ }
+
+ public static class exists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, exists_args> {
+ public exists() {
+ super("exists");
+ }
+
+ public exists_args getEmptyArgsInstance() {
+ return new exists_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public exists_result getResult(I iface, exists_args args) throws org.apache.thrift.TException {
+ exists_result result = new exists_result();
+ try {
+ result.success = iface.exists(args.table, args.tget);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class existsAll<I extends Iface> extends org.apache.thrift.ProcessFunction<I, existsAll_args> {
+ public existsAll() {
+ super("existsAll");
+ }
+
+ public existsAll_args getEmptyArgsInstance() {
+ return new existsAll_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public existsAll_result getResult(I iface, existsAll_args args) throws org.apache.thrift.TException {
+ existsAll_result result = new existsAll_result();
+ try {
+ result.success = iface.existsAll(args.table, args.tgets);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
+ public get() {
+ super("get");
+ }
+
+ public get_args getEmptyArgsInstance() {
+ return new get_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
+ get_result result = new get_result();
+ try {
+ result.success = iface.get(args.table, args.tget);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMultiple_args> {
+ public getMultiple() {
+ super("getMultiple");
+ }
+
+ public getMultiple_args getEmptyArgsInstance() {
+ return new getMultiple_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getMultiple_result getResult(I iface, getMultiple_args args) throws org.apache.thrift.TException {
+ getMultiple_result result = new getMultiple_result();
+ try {
+ result.success = iface.getMultiple(args.table, args.tgets);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class put<I extends Iface> extends org.apache.thrift.ProcessFunction<I, put_args> {
+ public put() {
+ super("put");
+ }
+
+ public put_args getEmptyArgsInstance() {
+ return new put_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public put_result getResult(I iface, put_args args) throws org.apache.thrift.TException {
+ put_result result = new put_result();
+ try {
+ iface.put(args.table, args.tput);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
+ public checkAndPut() {
+ super("checkAndPut");
+ }
+
+ public checkAndPut_args getEmptyArgsInstance() {
+ return new checkAndPut_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
+ checkAndPut_result result = new checkAndPut_result();
+ try {
+ result.success = iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.tput);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class putMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, putMultiple_args> {
+ public putMultiple() {
+ super("putMultiple");
+ }
+
+ public putMultiple_args getEmptyArgsInstance() {
+ return new putMultiple_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public putMultiple_result getResult(I iface, putMultiple_args args) throws org.apache.thrift.TException {
+ putMultiple_result result = new putMultiple_result();
+ try {
+ iface.putMultiple(args.table, args.tputs);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteSingle<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteSingle_args> {
+ public deleteSingle() {
+ super("deleteSingle");
+ }
+
+ public deleteSingle_args getEmptyArgsInstance() {
+ return new deleteSingle_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteSingle_result getResult(I iface, deleteSingle_args args) throws org.apache.thrift.TException {
+ deleteSingle_result result = new deleteSingle_result();
+ try {
+ iface.deleteSingle(args.table, args.tdelete);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteMultiple_args> {
+ public deleteMultiple() {
+ super("deleteMultiple");
+ }
+
+ public deleteMultiple_args getEmptyArgsInstance() {
+ return new deleteMultiple_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteMultiple_result getResult(I iface, deleteMultiple_args args) throws org.apache.thrift.TException {
+ deleteMultiple_result result = new deleteMultiple_result();
+ try {
+ result.success = iface.deleteMultiple(args.table, args.tdeletes);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class checkAndDelete<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndDelete_args> {
+ public checkAndDelete() {
+ super("checkAndDelete");
+ }
+
+ public checkAndDelete_args getEmptyArgsInstance() {
+ return new checkAndDelete_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public checkAndDelete_result getResult(I iface, checkAndDelete_args args) throws org.apache.thrift.TException {
+ checkAndDelete_result result = new checkAndDelete_result();
+ try {
+ result.success = iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.tdelete);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
+ public increment() {
+ super("increment");
+ }
+
+ public increment_args getEmptyArgsInstance() {
+ return new increment_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
+ increment_result result = new increment_result();
+ try {
+ result.success = iface.increment(args.table, args.tincrement);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class append<I extends Iface> extends org.apache.thrift.ProcessFunction<I, append_args> {
+ public append() {
+ super("append");
+ }
+
+ public append_args getEmptyArgsInstance() {
+ return new append_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public append_result getResult(I iface, append_args args) throws org.apache.thrift.TException {
+ append_result result = new append_result();
+ try {
+ result.success = iface.append(args.table, args.tappend);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class openScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, openScanner_args> {
+ public openScanner() {
+ super("openScanner");
+ }
+
+ public openScanner_args getEmptyArgsInstance() {
+ return new openScanner_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public openScanner_result getResult(I iface, openScanner_args args) throws org.apache.thrift.TException {
+ openScanner_result result = new openScanner_result();
+ try {
+ result.success = iface.openScanner(args.table, args.tscan);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getScannerRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerRows_args> {
+ public getScannerRows() {
+ super("getScannerRows");
+ }
+
+ public getScannerRows_args getEmptyArgsInstance() {
+ return new getScannerRows_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getScannerRows_result getResult(I iface, getScannerRows_args args) throws org.apache.thrift.TException {
+ getScannerRows_result result = new getScannerRows_result();
+ try {
+ result.success = iface.getScannerRows(args.scannerId, args.numRows);
+ } catch (TIOError io) {
+ result.io = io;
+ } catch (TIllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class closeScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScanner_args> {
+ public closeScanner() {
+ super("closeScanner");
+ }
+
+ public closeScanner_args getEmptyArgsInstance() {
+ return new closeScanner_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public closeScanner_result getResult(I iface, closeScanner_args args) throws org.apache.thrift.TException {
+ closeScanner_result result = new closeScanner_result();
+ try {
+ iface.closeScanner(args.scannerId);
+ } catch (TIOError io) {
+ result.io = io;
+ } catch (TIllegalArgument ia) {
+ result.ia = ia;
+ }
+ return result;
+ }
+ }
+
+ public static class mutateRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRow_args> {
+ public mutateRow() {
+ super("mutateRow");
+ }
+
+ public mutateRow_args getEmptyArgsInstance() {
+ return new mutateRow_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public mutateRow_result getResult(I iface, mutateRow_args args) throws org.apache.thrift.TException {
+ mutateRow_result result = new mutateRow_result();
+ try {
+ iface.mutateRow(args.table, args.trowMutations);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getScannerResults<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerResults_args> {
+ public getScannerResults() {
+ super("getScannerResults");
+ }
+
+ public getScannerResults_args getEmptyArgsInstance() {
+ return new getScannerResults_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getScannerResults_result getResult(I iface, getScannerResults_args args) throws org.apache.thrift.TException {
+ getScannerResults_result result = new getScannerResults_result();
+ try {
+ result.success = iface.getScannerResults(args.table, args.tscan, args.numRows);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getRegionLocation<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRegionLocation_args> {
+ public getRegionLocation() {
+ super("getRegionLocation");
+ }
+
+ public getRegionLocation_args getEmptyArgsInstance() {
+ return new getRegionLocation_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getRegionLocation_result getResult(I iface, getRegionLocation_args args) throws org.apache.thrift.TException {
+ getRegionLocation_result result = new getRegionLocation_result();
+ try {
+ result.success = iface.getRegionLocation(args.table, args.row, args.reload);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getAllRegionLocations<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllRegionLocations_args> {
+ public getAllRegionLocations() {
+ super("getAllRegionLocations");
+ }
+
+ public getAllRegionLocations_args getEmptyArgsInstance() {
+ return new getAllRegionLocations_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getAllRegionLocations_result getResult(I iface, getAllRegionLocations_args args) throws org.apache.thrift.TException {
+ getAllRegionLocations_result result = new getAllRegionLocations_result();
+ try {
+ result.success = iface.getAllRegionLocations(args.table);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class checkAndMutate<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndMutate_args> {
+ public checkAndMutate() {
+ super("checkAndMutate");
+ }
+
+ public checkAndMutate_args getEmptyArgsInstance() {
+ return new checkAndMutate_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public checkAndMutate_result getResult(I iface, checkAndMutate_args args) throws org.apache.thrift.TException {
+ checkAndMutate_result result = new checkAndMutate_result();
+ try {
+ result.success = iface.checkAndMutate(args.table, args.row, args.family, args.qualifier, args.compareOperator, args.value, args.rowMutations);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableDescriptor<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableDescriptor_args> {
+ public getTableDescriptor() {
+ super("getTableDescriptor");
+ }
+
+ public getTableDescriptor_args getEmptyArgsInstance() {
+ return new getTableDescriptor_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableDescriptor_result getResult(I iface, getTableDescriptor_args args) throws org.apache.thrift.TException {
+ getTableDescriptor_result result = new getTableDescriptor_result();
+ try {
+ result.success = iface.getTableDescriptor(args.table);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableDescriptors<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableDescriptors_args> {
+ public getTableDescriptors() {
+ super("getTableDescriptors");
+ }
+
+ public getTableDescriptors_args getEmptyArgsInstance() {
+ return new getTableDescriptors_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableDescriptors_result getResult(I iface, getTableDescriptors_args args) throws org.apache.thrift.TException {
+ getTableDescriptors_result result = new getTableDescriptors_result();
+ try {
+ result.success = iface.getTableDescriptors(args.tables);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class tableExists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, tableExists_args> {
+ public tableExists() {
+ super("tableExists");
+ }
+
+ public tableExists_args getEmptyArgsInstance() {
+ return new tableExists_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public tableExists_result getResult(I iface, tableExists_args args) throws org.apache.thrift.TException {
+ tableExists_result result = new tableExists_result();
+ try {
+ result.success = iface.tableExists(args.tableName);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableDescriptorsByPattern<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableDescriptorsByPattern_args> {
+ public getTableDescriptorsByPattern() {
+ super("getTableDescriptorsByPattern");
+ }
+
+ public getTableDescriptorsByPattern_args getEmptyArgsInstance() {
+ return new getTableDescriptorsByPattern_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableDescriptorsByPattern_result getResult(I iface, getTableDescriptorsByPattern_args args) throws org.apache.thrift.TException {
+ getTableDescriptorsByPattern_result result = new getTableDescriptorsByPattern_result();
+ try {
+ result.success = iface.getTableDescriptorsByPattern(args.regex, args.includeSysTables);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableDescriptorsByNamespace<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableDescriptorsByNamespace_args> {
+ public getTableDescriptorsByNamespace() {
+ super("getTableDescriptorsByNamespace");
+ }
+
+ public getTableDescriptorsByNamespace_args getEmptyArgsInstance() {
+ return new getTableDescriptorsByNamespace_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableDescriptorsByNamespace_result getResult(I iface, getTableDescriptorsByNamespace_args args) throws org.apache.thrift.TException {
+ getTableDescriptorsByNamespace_result result = new getTableDescriptorsByNamespace_result();
+ try {
+ result.success = iface.getTableDescriptorsByNamespace(args.name);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableNamesByPattern<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableNamesByPattern_args> {
+ public getTableNamesByPattern() {
+ super("getTableNamesByPattern");
+ }
+
+ public getTableNamesByPattern_args getEmptyArgsInstance() {
+ return new getTableNamesByPattern_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableNamesByPattern_result getResult(I iface, getTableNamesByPattern_args args) throws org.apache.thrift.TException {
+ getTableNamesByPattern_result result = new getTableNamesByPattern_result();
+ try {
+ result.success = iface.getTableNamesByPattern(args.regex, args.includeSysTables);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getTableNamesByNamespace<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getTableNamesByNamespace_args> {
+ public getTableNamesByNamespace() {
+ super("getTableNamesByNamespace");
+ }
+
+ public getTableNamesByNamespace_args getEmptyArgsInstance() {
+ return new getTableNamesByNamespace_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getTableNamesByNamespace_result getResult(I iface, getTableNamesByNamespace_args args) throws org.apache.thrift.TException {
+ getTableNamesByNamespace_result result = new getTableNamesByNamespace_result();
+ try {
+ result.success = iface.getTableNamesByNamespace(args.name);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class createTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createTable_args> {
+ public createTable() {
+ super("createTable");
+ }
+
+ public createTable_args getEmptyArgsInstance() {
+ return new createTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public createTable_result getResult(I iface, createTable_args args) throws org.apache.thrift.TException {
+ createTable_result result = new createTable_result();
+ try {
+ iface.createTable(args.desc, args.splitKeys);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteTable_args> {
+ public deleteTable() {
+ super("deleteTable");
+ }
+
+ public deleteTable_args getEmptyArgsInstance() {
+ return new deleteTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteTable_result getResult(I iface, deleteTable_args args) throws org.apache.thrift.TException {
+ deleteTable_result result = new deleteTable_result();
+ try {
+ iface.deleteTable(args.tableName);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class truncateTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, truncateTable_args> {
+ public truncateTable() {
+ super("truncateTable");
+ }
+
+ public truncateTable_args getEmptyArgsInstance() {
+ return new truncateTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public truncateTable_result getResult(I iface, truncateTable_args args) throws org.apache.thrift.TException {
+ truncateTable_result result = new truncateTable_result();
+ try {
+ iface.truncateTable(args.tableName, args.preserveSplits);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class enableTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, enableTable_args> {
+ public enableTable() {
+ super("enableTable");
+ }
+
+ public enableTable_args getEmptyArgsInstance() {
+ return new enableTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public enableTable_result getResult(I iface, enableTable_args args) throws org.apache.thrift.TException {
+ enableTable_result result = new enableTable_result();
+ try {
+ iface.enableTable(args.tableName);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class disableTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, disableTable_args> {
+ public disableTable() {
+ super("disableTable");
+ }
+
+ public disableTable_args getEmptyArgsInstance() {
+ return new disableTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public disableTable_result getResult(I iface, disableTable_args args) throws org.apache.thrift.TException {
+ disableTable_result result = new disableTable_result();
+ try {
+ iface.disableTable(args.tableName);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class isTableEnabled<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTableEnabled_args> {
+ public isTableEnabled() {
+ super("isTableEnabled");
+ }
+
+ public isTableEnabled_args getEmptyArgsInstance() {
+ return new isTableEnabled_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public isTableEnabled_result getResult(I iface, isTableEnabled_args args) throws org.apache.thrift.TException {
+ isTableEnabled_result result = new isTableEnabled_result();
+ try {
+ result.success = iface.isTableEnabled(args.tableName);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class isTableDisabled<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTableDisabled_args> {
+ public isTableDisabled() {
+ super("isTableDisabled");
+ }
+
+ public isTableDisabled_args getEmptyArgsInstance() {
+ return new isTableDisabled_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public isTableDisabled_result getResult(I iface, isTableDisabled_args args) throws org.apache.thrift.TException {
+ isTableDisabled_result result = new isTableDisabled_result();
+ try {
+ result.success = iface.isTableDisabled(args.tableName);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class isTableAvailable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTableAvailable_args> {
+ public isTableAvailable() {
+ super("isTableAvailable");
+ }
+
+ public isTableAvailable_args getEmptyArgsInstance() {
+ return new isTableAvailable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public isTableAvailable_result getResult(I iface, isTableAvailable_args args) throws org.apache.thrift.TException {
+ isTableAvailable_result result = new isTableAvailable_result();
+ try {
+ result.success = iface.isTableAvailable(args.tableName);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class isTableAvailableWithSplit<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTableAvailableWithSplit_args> {
+ public isTableAvailableWithSplit() {
+ super("isTableAvailableWithSplit");
+ }
+
+ public isTableAvailableWithSplit_args getEmptyArgsInstance() {
+ return new isTableAvailableWithSplit_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public isTableAvailableWithSplit_result getResult(I iface, isTableAvailableWithSplit_args args) throws org.apache.thrift.TException {
+ isTableAvailableWithSplit_result result = new isTableAvailableWithSplit_result();
+ try {
+ result.success = iface.isTableAvailableWithSplit(args.tableName, args.splitKeys);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class addColumnFamily<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addColumnFamily_args> {
+ public addColumnFamily() {
+ super("addColumnFamily");
+ }
+
+ public addColumnFamily_args getEmptyArgsInstance() {
+ return new addColumnFamily_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public addColumnFamily_result getResult(I iface, addColumnFamily_args args) throws org.apache.thrift.TException {
+ addColumnFamily_result result = new addColumnFamily_result();
+ try {
+ iface.addColumnFamily(args.tableName, args.column);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteColumnFamily<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteColumnFamily_args> {
+ public deleteColumnFamily() {
+ super("deleteColumnFamily");
+ }
+
+ public deleteColumnFamily_args getEmptyArgsInstance() {
+ return new deleteColumnFamily_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteColumnFamily_result getResult(I iface, deleteColumnFamily_args args) throws org.apache.thrift.TException {
+ deleteColumnFamily_result result = new deleteColumnFamily_result();
+ try {
+ iface.deleteColumnFamily(args.tableName, args.column);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class modifyColumnFamily<I extends Iface> extends org.apache.thrift.ProcessFunction<I, modifyColumnFamily_args> {
+ public modifyColumnFamily() {
+ super("modifyColumnFamily");
+ }
+
+ public modifyColumnFamily_args getEmptyArgsInstance() {
+ return new modifyColumnFamily_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public modifyColumnFamily_result getResult(I iface, modifyColumnFamily_args args) throws org.apache.thrift.TException {
+ modifyColumnFamily_result result = new modifyColumnFamily_result();
+ try {
+ iface.modifyColumnFamily(args.tableName, args.column);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class modifyTable<I extends Iface> extends org.apache.thrift.ProcessFunction<I, modifyTable_args> {
+ public modifyTable() {
+ super("modifyTable");
+ }
+
+ public modifyTable_args getEmptyArgsInstance() {
+ return new modifyTable_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public modifyTable_result getResult(I iface, modifyTable_args args) throws org.apache.thrift.TException {
+ modifyTable_result result = new modifyTable_result();
+ try {
+ iface.modifyTable(args.desc);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class createNamespace<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createNamespace_args> {
+ public createNamespace() {
+ super("createNamespace");
+ }
+
+ public createNamespace_args getEmptyArgsInstance() {
+ return new createNamespace_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public createNamespace_result getResult(I iface, createNamespace_args args) throws org.apache.thrift.TException {
+ createNamespace_result result = new createNamespace_result();
+ try {
+ iface.createNamespace(args.namespaceDesc);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class modifyNamespace<I extends Iface> extends org.apache.thrift.ProcessFunction<I, modifyNamespace_args> {
+ public modifyNamespace() {
+ super("modifyNamespace");
+ }
+
+ public modifyNamespace_args getEmptyArgsInstance() {
+ return new modifyNamespace_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public modifyNamespace_result getResult(I iface, modifyNamespace_args args) throws org.apache.thrift.TException {
+ modifyNamespace_result result = new modifyNamespace_result();
+ try {
+ iface.modifyNamespace(args.namespaceDesc);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class deleteNamespace<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteNamespace_args> {
+ public deleteNamespace() {
+ super("deleteNamespace");
+ }
+
+ public deleteNamespace_args getEmptyArgsInstance() {
+ return new deleteNamespace_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public deleteNamespace_result getResult(I iface, deleteNamespace_args args) throws org.apache.thrift.TException {
+ deleteNamespace_result result = new deleteNamespace_result();
+ try {
+ iface.deleteNamespace(args.name);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getNamespaceDescriptor<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getNamespaceDescriptor_args> {
+ public getNamespaceDescriptor() {
+ super("getNamespaceDescriptor");
+ }
+
+ public getNamespaceDescriptor_args getEmptyArgsInstance() {
+ return new getNamespaceDescriptor_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getNamespaceDescriptor_result getResult(I iface, getNamespaceDescriptor_args args) throws org.apache.thrift.TException {
+ getNamespaceDescriptor_result result = new getNamespaceDescriptor_result();
+ try {
+ result.success = iface.getNamespaceDescriptor(args.name);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class listNamespaceDescriptors<I extends Iface> extends org.apache.thrift.ProcessFunction<I, listNamespaceDescriptors_args> {
+ public listNamespaceDescriptors() {
+ super("listNamespaceDescriptors");
+ }
+
+ public listNamespaceDescriptors_args getEmptyArgsInstance() {
+ return new listNamespaceDescriptors_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public listNamespaceDescriptors_result getResult(I iface, listNamespaceDescriptors_args args) throws org.apache.thrift.TException {
+ listNamespaceDescriptors_result result = new listNamespaceDescriptors_result();
+ try {
+ result.success = iface.listNamespaceDescriptors();
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class listNamespaces<I extends Iface> extends org.apache.thrift.ProcessFunction<I, listNamespaces_args> {
+ public listNamespaces() {
+ super("listNamespaces");
+ }
+
+ public listNamespaces_args getEmptyArgsInstance() {
+ return new listNamespaces_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public listNamespaces_result getResult(I iface, listNamespaces_args args) throws org.apache.thrift.TException {
+ listNamespaces_result result = new listNamespaces_result();
+ try {
+ result.success = iface.listNamespaces();
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class getThriftServerType<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getThriftServerType_args> {
+ public getThriftServerType() {
+ super("getThriftServerType");
+ }
+
+ public getThriftServerType_args getEmptyArgsInstance() {
+ return new getThriftServerType_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getThriftServerType_result getResult(I iface, getThriftServerType_args args) throws org.apache.thrift.TException {
+ getThriftServerType_result result = new getThriftServerType_result();
+ result.success = iface.getThriftServerType();
+ return result;
+ }
+ }
+
+ public static class getClusterId<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getClusterId_args> {
+ public getClusterId() {
+ super("getClusterId");
+ }
+
+ public getClusterId_args getEmptyArgsInstance() {
+ return new getClusterId_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getClusterId_result getResult(I iface, getClusterId_args args) throws org.apache.thrift.TException {
+ getClusterId_result result = new getClusterId_result();
+ result.success = iface.getClusterId();
+ return result;
+ }
+ }
+
+ public static class getSlowLogResponses<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getSlowLogResponses_args> {
+ public getSlowLogResponses() {
+ super("getSlowLogResponses");
+ }
+
+ public getSlowLogResponses_args getEmptyArgsInstance() {
+ return new getSlowLogResponses_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public getSlowLogResponses_result getResult(I iface, getSlowLogResponses_args args) throws org.apache.thrift.TException {
+ getSlowLogResponses_result result = new getSlowLogResponses_result();
+ try {
+ result.success = iface.getSlowLogResponses(args.serverNames, args.logQueryFilter);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class clearSlowLogResponses<I extends Iface> extends org.apache.thrift.ProcessFunction<I, clearSlowLogResponses_args> {
+ public clearSlowLogResponses() {
+ super("clearSlowLogResponses");
+ }
+
+ public clearSlowLogResponses_args getEmptyArgsInstance() {
+ return new clearSlowLogResponses_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public clearSlowLogResponses_result getResult(I iface, clearSlowLogResponses_args args) throws org.apache.thrift.TException {
+ clearSlowLogResponses_result result = new clearSlowLogResponses_result();
+ try {
+ result.success = iface.clearSlowLogResponses(args.serverNames);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class grant<I extends Iface> extends org.apache.thrift.ProcessFunction<I, grant_args> {
+ public grant() {
+ super("grant");
+ }
+
+ public grant_args getEmptyArgsInstance() {
+ return new grant_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public grant_result getResult(I iface, grant_args args) throws org.apache.thrift.TException {
+ grant_result result = new grant_result();
+ try {
+ result.success = iface.grant(args.info);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ public static class revoke<I extends Iface> extends org.apache.thrift.ProcessFunction<I, revoke_args> {
+ public revoke() {
+ super("revoke");
+ }
+
+ public revoke_args getEmptyArgsInstance() {
+ return new revoke_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public revoke_result getResult(I iface, revoke_args args) throws org.apache.thrift.TException {
+ revoke_result result = new revoke_result();
+ try {
+ result.success = iface.revoke(args.info);
+ result.setSuccessIsSet(true);
+ } catch (TIOError io) {
+ result.io = io;
+ }
+ return result;
+ }
+ }
+
+ }
+
+ public static class AsyncProcessor<I extends AsyncIface> extends org.apache.thrift.TBaseAsyncProcessor<I> {
+ private static final org.slf4j.Logger _LOGGER = org.slf4j.LoggerFactory.getLogger(AsyncProcessor.class.getName());
+ public AsyncProcessor(I iface) {
+ super(iface, getProcessMap(new java.util.HashMap<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>>()));
+ }
+
+ protected AsyncProcessor(I iface, java.util.Map<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>> processMap) {
+ super(iface, getProcessMap(processMap));
+ }
+
+ private static <I extends AsyncIface> java.util.Map<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase,?>> getProcessMap(java.util.Map<java.lang.String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>> processMap) {
+ processMap.put("exists", new exists());
+ processMap.put("existsAll", new existsAll());
+ processMap.put("get", new get());
+ processMap.put("getMultiple", new getMultiple());
+ processMap.put("put", new put());
+ processMap.put("checkAndPut", new checkAndPut());
+ processMap.put("putMultiple", new putMultiple());
+ processMap.put("deleteSingle", new deleteSingle());
+ processMap.put("deleteMultiple", new deleteMultiple());
+ processMap.put("checkAndDelete", new checkAndDelete());
+ processMap.put("increment", new increment());
+ processMap.put("append", new append());
+ processMap.put("openScanner", new openScanner());
+ processMap.put("getScannerRows", new getScannerRows());
+ processMap.put("closeScanner", new closeScanner());
+ processMap.put("mutateRow", new mutateRow());
+ processMap.put("getScannerResults", new getScannerResults());
+ processMap.put("getRegionLocation", new getRegionLocation());
+ processMap.put("getAllRegionLocations", new getAllRegionLocations());
+ processMap.put("checkAndMutate", new checkAndMutate());
+ processMap.put("getTableDescriptor", new getTableDescriptor());
+ processMap.put("getTableDescriptors", new getTableDescriptors());
+ processMap.put("tableExists", new tableExists());
+ processMap.put("getTableDescriptorsByPattern", new getTableDescriptorsByPattern());
+ processMap.put("getTableDescriptorsByNamespace", new getTableDescriptorsByNamespace());
+ processMap.put("getTableNamesByPattern", new getTableNamesByPattern());
+ processMap.put("getTableNamesByNamespace", new getTableNamesByNamespace());
+ processMap.put("createTable", new createTable());
+ processMap.put("deleteTable", new deleteTable());
+ processMap.put("truncateTable", new truncateTable());
+ processMap.put("enableTable", new enableTable());
+ processMap.put("disableTable", new disableTable());
+ processMap.put("isTableEnabled", new isTableEnabled());
+ processMap.put("isTableDisabled", new isTableDisabled());
+ processMap.put("isTableAvailable", new isTableAvailable());
+ processMap.put("isTableAvailableWithSplit", new isTableAvailableWithSplit());
+ processMap.put("addColumnFamily", new addColumnFamily());
+ processMap.put("deleteColumnFamily", new deleteColumnFamily());
+ processMap.put("modifyColumnFamily", new modifyColumnFamily());
+ processMap.put("modifyTable", new modifyTable());
+ processMap.put("createNamespace", new createNamespace());
+ processMap.put("modifyNamespace", new modifyNamespace());
+ processMap.put("deleteNamespace", new deleteNamespace());
+ processMap.put("getNamespaceDescriptor", new getNamespaceDescriptor());
+ processMap.put("listNamespaceDescriptors", new listNamespaceDescriptors());
+ processMap.put("listNamespaces", new listNamespaces());
+ processMap.put("getThriftServerType", new getThriftServerType());
+ processMap.put("getClusterId", new getClusterId());
+ processMap.put("getSlowLogResponses", new getSlowLogResponses());
+ processMap.put("clearSlowLogResponses", new clearSlowLogResponses());
+ processMap.put("grant", new grant());
+ processMap.put("revoke", new revoke());
+ return processMap;
+ }
+
+ public static class exists<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, exists_args, java.lang.Boolean> {
+ public exists() {
+ super("exists");
+ }
+
+ public exists_args getEmptyArgsInstance() {
+ return new exists_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ exists_result result = new exists_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ exists_result result = new exists_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, exists_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.exists(args.table, args.tget,resultHandler);
+ }
+ }
+
+ public static class existsAll<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, existsAll_args, java.util.List<java.lang.Boolean>> {
+ public existsAll() {
+ super("existsAll");
+ }
+
+ public existsAll_args getEmptyArgsInstance() {
+ return new existsAll_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>>() {
+ public void onComplete(java.util.List<java.lang.Boolean> o) {
+ existsAll_result result = new existsAll_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ existsAll_result result = new existsAll_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, existsAll_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException {
+ iface.existsAll(args.table, args.tgets,resultHandler);
+ }
+ }
+
+ public static class get<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, get_args, TResult> {
+ public get() {
+ super("get");
+ }
+
+ public get_args getEmptyArgsInstance() {
+ return new get_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TResult> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TResult>() {
+ public void onComplete(TResult o) {
+ get_result result = new get_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ get_result result = new get_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, get_args args, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException {
+ iface.get(args.table, args.tget,resultHandler);
+ }
+ }
+
+ public static class getMultiple<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getMultiple_args, java.util.List<TResult>> {
+ public getMultiple() {
+ super("getMultiple");
+ }
+
+ public getMultiple_args getEmptyArgsInstance() {
+ return new getMultiple_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>>() {
+ public void onComplete(java.util.List<TResult> o) {
+ getMultiple_result result = new getMultiple_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getMultiple_result result = new getMultiple_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getMultiple_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getMultiple(args.table, args.tgets,resultHandler);
+ }
+ }
+
+ public static class put<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, put_args, Void> {
+ public put() {
+ super("put");
+ }
+
+ public put_args getEmptyArgsInstance() {
+ return new put_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ put_result result = new put_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ put_result result = new put_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, put_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.put(args.table, args.tput,resultHandler);
+ }
+ }
+
+ public static class checkAndPut<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, checkAndPut_args, java.lang.Boolean> {
+ public checkAndPut() {
+ super("checkAndPut");
+ }
+
+ public checkAndPut_args getEmptyArgsInstance() {
+ return new checkAndPut_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ checkAndPut_result result = new checkAndPut_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ checkAndPut_result result = new checkAndPut_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, checkAndPut_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.tput,resultHandler);
+ }
+ }
+
+ public static class putMultiple<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, putMultiple_args, Void> {
+ public putMultiple() {
+ super("putMultiple");
+ }
+
+ public putMultiple_args getEmptyArgsInstance() {
+ return new putMultiple_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ putMultiple_result result = new putMultiple_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ putMultiple_result result = new putMultiple_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, putMultiple_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.putMultiple(args.table, args.tputs,resultHandler);
+ }
+ }
+
+ public static class deleteSingle<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteSingle_args, Void> {
+ public deleteSingle() {
+ super("deleteSingle");
+ }
+
+ public deleteSingle_args getEmptyArgsInstance() {
+ return new deleteSingle_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteSingle_result result = new deleteSingle_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteSingle_result result = new deleteSingle_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteSingle_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteSingle(args.table, args.tdelete,resultHandler);
+ }
+ }
+
+ public static class deleteMultiple<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteMultiple_args, java.util.List<TDelete>> {
+ public deleteMultiple() {
+ super("deleteMultiple");
+ }
+
+ public deleteMultiple_args getEmptyArgsInstance() {
+ return new deleteMultiple_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TDelete>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TDelete>>() {
+ public void onComplete(java.util.List<TDelete> o) {
+ deleteMultiple_result result = new deleteMultiple_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteMultiple_result result = new deleteMultiple_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteMultiple_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TDelete>> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteMultiple(args.table, args.tdeletes,resultHandler);
+ }
+ }
+
+ public static class checkAndDelete<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, checkAndDelete_args, java.lang.Boolean> {
+ public checkAndDelete() {
+ super("checkAndDelete");
+ }
+
+ public checkAndDelete_args getEmptyArgsInstance() {
+ return new checkAndDelete_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ checkAndDelete_result result = new checkAndDelete_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ checkAndDelete_result result = new checkAndDelete_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, checkAndDelete_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.tdelete,resultHandler);
+ }
+ }
+
+ public static class increment<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, increment_args, TResult> {
+ public increment() {
+ super("increment");
+ }
+
+ public increment_args getEmptyArgsInstance() {
+ return new increment_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TResult> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TResult>() {
+ public void onComplete(TResult o) {
+ increment_result result = new increment_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ increment_result result = new increment_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, increment_args args, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException {
+ iface.increment(args.table, args.tincrement,resultHandler);
+ }
+ }
+
+ public static class append<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, append_args, TResult> {
+ public append() {
+ super("append");
+ }
+
+ public append_args getEmptyArgsInstance() {
+ return new append_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TResult> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TResult>() {
+ public void onComplete(TResult o) {
+ append_result result = new append_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ append_result result = new append_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, append_args args, org.apache.thrift.async.AsyncMethodCallback<TResult> resultHandler) throws org.apache.thrift.TException {
+ iface.append(args.table, args.tappend,resultHandler);
+ }
+ }
+
+ public static class openScanner<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, openScanner_args, java.lang.Integer> {
+ public openScanner() {
+ super("openScanner");
+ }
+
+ public openScanner_args getEmptyArgsInstance() {
+ return new openScanner_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer>() {
+ public void onComplete(java.lang.Integer o) {
+ openScanner_result result = new openScanner_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ openScanner_result result = new openScanner_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, openScanner_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Integer> resultHandler) throws org.apache.thrift.TException {
+ iface.openScanner(args.table, args.tscan,resultHandler);
+ }
+ }
+
+ public static class getScannerRows<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getScannerRows_args, java.util.List<TResult>> {
+ public getScannerRows() {
+ super("getScannerRows");
+ }
+
+ public getScannerRows_args getEmptyArgsInstance() {
+ return new getScannerRows_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>>() {
+ public void onComplete(java.util.List<TResult> o) {
+ getScannerRows_result result = new getScannerRows_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getScannerRows_result result = new getScannerRows_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof TIllegalArgument) {
+ result.ia = (TIllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getScannerRows_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getScannerRows(args.scannerId, args.numRows,resultHandler);
+ }
+ }
+
+ public static class closeScanner<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, closeScanner_args, Void> {
+ public closeScanner() {
+ super("closeScanner");
+ }
+
+ public closeScanner_args getEmptyArgsInstance() {
+ return new closeScanner_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ closeScanner_result result = new closeScanner_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ closeScanner_result result = new closeScanner_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof TIllegalArgument) {
+ result.ia = (TIllegalArgument) e;
+ result.setIaIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, closeScanner_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.closeScanner(args.scannerId,resultHandler);
+ }
+ }
+
+ public static class mutateRow<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, mutateRow_args, Void> {
+ public mutateRow() {
+ super("mutateRow");
+ }
+
+ public mutateRow_args getEmptyArgsInstance() {
+ return new mutateRow_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ mutateRow_result result = new mutateRow_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ mutateRow_result result = new mutateRow_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, mutateRow_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.mutateRow(args.table, args.trowMutations,resultHandler);
+ }
+ }
+
+ public static class getScannerResults<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getScannerResults_args, java.util.List<TResult>> {
+ public getScannerResults() {
+ super("getScannerResults");
+ }
+
+ public getScannerResults_args getEmptyArgsInstance() {
+ return new getScannerResults_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>>() {
+ public void onComplete(java.util.List<TResult> o) {
+ getScannerResults_result result = new getScannerResults_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getScannerResults_result result = new getScannerResults_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getScannerResults_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TResult>> resultHandler) throws org.apache.thrift.TException {
+ iface.getScannerResults(args.table, args.tscan, args.numRows,resultHandler);
+ }
+ }
+
+ public static class getRegionLocation<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getRegionLocation_args, THRegionLocation> {
+ public getRegionLocation() {
+ super("getRegionLocation");
+ }
+
+ public getRegionLocation_args getEmptyArgsInstance() {
+ return new getRegionLocation_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<THRegionLocation> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<THRegionLocation>() {
+ public void onComplete(THRegionLocation o) {
+ getRegionLocation_result result = new getRegionLocation_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getRegionLocation_result result = new getRegionLocation_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getRegionLocation_args args, org.apache.thrift.async.AsyncMethodCallback<THRegionLocation> resultHandler) throws org.apache.thrift.TException {
+ iface.getRegionLocation(args.table, args.row, args.reload,resultHandler);
+ }
+ }
+
+ public static class getAllRegionLocations<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getAllRegionLocations_args, java.util.List<THRegionLocation>> {
+ public getAllRegionLocations() {
+ super("getAllRegionLocations");
+ }
+
+ public getAllRegionLocations_args getEmptyArgsInstance() {
+ return new getAllRegionLocations_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<THRegionLocation>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<THRegionLocation>>() {
+ public void onComplete(java.util.List<THRegionLocation> o) {
+ getAllRegionLocations_result result = new getAllRegionLocations_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getAllRegionLocations_result result = new getAllRegionLocations_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getAllRegionLocations_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<THRegionLocation>> resultHandler) throws org.apache.thrift.TException {
+ iface.getAllRegionLocations(args.table,resultHandler);
+ }
+ }
+
+ public static class checkAndMutate<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, checkAndMutate_args, java.lang.Boolean> {
+ public checkAndMutate() {
+ super("checkAndMutate");
+ }
+
+ public checkAndMutate_args getEmptyArgsInstance() {
+ return new checkAndMutate_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ checkAndMutate_result result = new checkAndMutate_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ checkAndMutate_result result = new checkAndMutate_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, checkAndMutate_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.checkAndMutate(args.table, args.row, args.family, args.qualifier, args.compareOperator, args.value, args.rowMutations,resultHandler);
+ }
+ }
+
+ public static class getTableDescriptor<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableDescriptor_args, TTableDescriptor> {
+ public getTableDescriptor() {
+ super("getTableDescriptor");
+ }
+
+ public getTableDescriptor_args getEmptyArgsInstance() {
+ return new getTableDescriptor_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TTableDescriptor> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TTableDescriptor>() {
+ public void onComplete(TTableDescriptor o) {
+ getTableDescriptor_result result = new getTableDescriptor_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableDescriptor_result result = new getTableDescriptor_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableDescriptor_args args, org.apache.thrift.async.AsyncMethodCallback<TTableDescriptor> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableDescriptor(args.table,resultHandler);
+ }
+ }
+
+ public static class getTableDescriptors<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableDescriptors_args, java.util.List<TTableDescriptor>> {
+ public getTableDescriptors() {
+ super("getTableDescriptors");
+ }
+
+ public getTableDescriptors_args getEmptyArgsInstance() {
+ return new getTableDescriptors_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>>() {
+ public void onComplete(java.util.List<TTableDescriptor> o) {
+ getTableDescriptors_result result = new getTableDescriptors_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableDescriptors_result result = new getTableDescriptors_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableDescriptors_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableDescriptors(args.tables,resultHandler);
+ }
+ }
+
+ public static class tableExists<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, tableExists_args, java.lang.Boolean> {
+ public tableExists() {
+ super("tableExists");
+ }
+
+ public tableExists_args getEmptyArgsInstance() {
+ return new tableExists_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ tableExists_result result = new tableExists_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ tableExists_result result = new tableExists_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, tableExists_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.tableExists(args.tableName,resultHandler);
+ }
+ }
+
+ public static class getTableDescriptorsByPattern<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableDescriptorsByPattern_args, java.util.List<TTableDescriptor>> {
+ public getTableDescriptorsByPattern() {
+ super("getTableDescriptorsByPattern");
+ }
+
+ public getTableDescriptorsByPattern_args getEmptyArgsInstance() {
+ return new getTableDescriptorsByPattern_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>>() {
+ public void onComplete(java.util.List<TTableDescriptor> o) {
+ getTableDescriptorsByPattern_result result = new getTableDescriptorsByPattern_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableDescriptorsByPattern_result result = new getTableDescriptorsByPattern_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableDescriptorsByPattern_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableDescriptorsByPattern(args.regex, args.includeSysTables,resultHandler);
+ }
+ }
+
+ public static class getTableDescriptorsByNamespace<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableDescriptorsByNamespace_args, java.util.List<TTableDescriptor>> {
+ public getTableDescriptorsByNamespace() {
+ super("getTableDescriptorsByNamespace");
+ }
+
+ public getTableDescriptorsByNamespace_args getEmptyArgsInstance() {
+ return new getTableDescriptorsByNamespace_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>>() {
+ public void onComplete(java.util.List<TTableDescriptor> o) {
+ getTableDescriptorsByNamespace_result result = new getTableDescriptorsByNamespace_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableDescriptorsByNamespace_result result = new getTableDescriptorsByNamespace_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableDescriptorsByNamespace_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableDescriptorsByNamespace(args.name,resultHandler);
+ }
+ }
+
+ public static class getTableNamesByPattern<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableNamesByPattern_args, java.util.List<TTableName>> {
+ public getTableNamesByPattern() {
+ super("getTableNamesByPattern");
+ }
+
+ public getTableNamesByPattern_args getEmptyArgsInstance() {
+ return new getTableNamesByPattern_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>>() {
+ public void onComplete(java.util.List<TTableName> o) {
+ getTableNamesByPattern_result result = new getTableNamesByPattern_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableNamesByPattern_result result = new getTableNamesByPattern_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableNamesByPattern_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableNamesByPattern(args.regex, args.includeSysTables,resultHandler);
+ }
+ }
+
+ public static class getTableNamesByNamespace<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getTableNamesByNamespace_args, java.util.List<TTableName>> {
+ public getTableNamesByNamespace() {
+ super("getTableNamesByNamespace");
+ }
+
+ public getTableNamesByNamespace_args getEmptyArgsInstance() {
+ return new getTableNamesByNamespace_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>>() {
+ public void onComplete(java.util.List<TTableName> o) {
+ getTableNamesByNamespace_result result = new getTableNamesByNamespace_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getTableNamesByNamespace_result result = new getTableNamesByNamespace_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getTableNamesByNamespace_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TTableName>> resultHandler) throws org.apache.thrift.TException {
+ iface.getTableNamesByNamespace(args.name,resultHandler);
+ }
+ }
+
+ public static class createTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, createTable_args, Void> {
+ public createTable() {
+ super("createTable");
+ }
+
+ public createTable_args getEmptyArgsInstance() {
+ return new createTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ createTable_result result = new createTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ createTable_result result = new createTable_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, createTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.createTable(args.desc, args.splitKeys,resultHandler);
+ }
+ }
+
+ public static class deleteTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteTable_args, Void> {
+ public deleteTable() {
+ super("deleteTable");
+ }
+
+ public deleteTable_args getEmptyArgsInstance() {
+ return new deleteTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteTable_result result = new deleteTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteTable_result result = new deleteTable_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteTable(args.tableName,resultHandler);
+ }
+ }
+
+ public static class truncateTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, truncateTable_args, Void> {
+ public truncateTable() {
+ super("truncateTable");
+ }
+
+ public truncateTable_args getEmptyArgsInstance() {
+ return new truncateTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ truncateTable_result result = new truncateTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ truncateTable_result result = new truncateTable_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, truncateTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.truncateTable(args.tableName, args.preserveSplits,resultHandler);
+ }
+ }
+
+ public static class enableTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, enableTable_args, Void> {
+ public enableTable() {
+ super("enableTable");
+ }
+
+ public enableTable_args getEmptyArgsInstance() {
+ return new enableTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ enableTable_result result = new enableTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ enableTable_result result = new enableTable_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, enableTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.enableTable(args.tableName,resultHandler);
+ }
+ }
+
+ public static class disableTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, disableTable_args, Void> {
+ public disableTable() {
+ super("disableTable");
+ }
+
+ public disableTable_args getEmptyArgsInstance() {
+ return new disableTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ disableTable_result result = new disableTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ disableTable_result result = new disableTable_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, disableTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.disableTable(args.tableName,resultHandler);
+ }
+ }
+
+ public static class isTableEnabled<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isTableEnabled_args, java.lang.Boolean> {
+ public isTableEnabled() {
+ super("isTableEnabled");
+ }
+
+ public isTableEnabled_args getEmptyArgsInstance() {
+ return new isTableEnabled_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ isTableEnabled_result result = new isTableEnabled_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ isTableEnabled_result result = new isTableEnabled_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, isTableEnabled_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.isTableEnabled(args.tableName,resultHandler);
+ }
+ }
+
+ public static class isTableDisabled<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isTableDisabled_args, java.lang.Boolean> {
+ public isTableDisabled() {
+ super("isTableDisabled");
+ }
+
+ public isTableDisabled_args getEmptyArgsInstance() {
+ return new isTableDisabled_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ isTableDisabled_result result = new isTableDisabled_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ isTableDisabled_result result = new isTableDisabled_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, isTableDisabled_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.isTableDisabled(args.tableName,resultHandler);
+ }
+ }
+
+ public static class isTableAvailable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isTableAvailable_args, java.lang.Boolean> {
+ public isTableAvailable() {
+ super("isTableAvailable");
+ }
+
+ public isTableAvailable_args getEmptyArgsInstance() {
+ return new isTableAvailable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ isTableAvailable_result result = new isTableAvailable_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ isTableAvailable_result result = new isTableAvailable_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, isTableAvailable_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.isTableAvailable(args.tableName,resultHandler);
+ }
+ }
+
+ public static class isTableAvailableWithSplit<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isTableAvailableWithSplit_args, java.lang.Boolean> {
+ public isTableAvailableWithSplit() {
+ super("isTableAvailableWithSplit");
+ }
+
+ public isTableAvailableWithSplit_args getEmptyArgsInstance() {
+ return new isTableAvailableWithSplit_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ isTableAvailableWithSplit_result result = new isTableAvailableWithSplit_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ isTableAvailableWithSplit_result result = new isTableAvailableWithSplit_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, isTableAvailableWithSplit_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.isTableAvailableWithSplit(args.tableName, args.splitKeys,resultHandler);
+ }
+ }
+
+ public static class addColumnFamily<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, addColumnFamily_args, Void> {
+ public addColumnFamily() {
+ super("addColumnFamily");
+ }
+
+ public addColumnFamily_args getEmptyArgsInstance() {
+ return new addColumnFamily_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ addColumnFamily_result result = new addColumnFamily_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ addColumnFamily_result result = new addColumnFamily_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, addColumnFamily_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.addColumnFamily(args.tableName, args.column,resultHandler);
+ }
+ }
+
+ public static class deleteColumnFamily<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteColumnFamily_args, Void> {
+ public deleteColumnFamily() {
+ super("deleteColumnFamily");
+ }
+
+ public deleteColumnFamily_args getEmptyArgsInstance() {
+ return new deleteColumnFamily_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteColumnFamily_result result = new deleteColumnFamily_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteColumnFamily_result result = new deleteColumnFamily_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteColumnFamily_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteColumnFamily(args.tableName, args.column,resultHandler);
+ }
+ }
+
+ public static class modifyColumnFamily<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, modifyColumnFamily_args, Void> {
+ public modifyColumnFamily() {
+ super("modifyColumnFamily");
+ }
+
+ public modifyColumnFamily_args getEmptyArgsInstance() {
+ return new modifyColumnFamily_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ modifyColumnFamily_result result = new modifyColumnFamily_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ modifyColumnFamily_result result = new modifyColumnFamily_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, modifyColumnFamily_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.modifyColumnFamily(args.tableName, args.column,resultHandler);
+ }
+ }
+
+ public static class modifyTable<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, modifyTable_args, Void> {
+ public modifyTable() {
+ super("modifyTable");
+ }
+
+ public modifyTable_args getEmptyArgsInstance() {
+ return new modifyTable_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ modifyTable_result result = new modifyTable_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ modifyTable_result result = new modifyTable_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, modifyTable_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.modifyTable(args.desc,resultHandler);
+ }
+ }
+
+ public static class createNamespace<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, createNamespace_args, Void> {
+ public createNamespace() {
+ super("createNamespace");
+ }
+
+ public createNamespace_args getEmptyArgsInstance() {
+ return new createNamespace_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ createNamespace_result result = new createNamespace_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ createNamespace_result result = new createNamespace_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, createNamespace_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.createNamespace(args.namespaceDesc,resultHandler);
+ }
+ }
+
+ public static class modifyNamespace<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, modifyNamespace_args, Void> {
+ public modifyNamespace() {
+ super("modifyNamespace");
+ }
+
+ public modifyNamespace_args getEmptyArgsInstance() {
+ return new modifyNamespace_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ modifyNamespace_result result = new modifyNamespace_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ modifyNamespace_result result = new modifyNamespace_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, modifyNamespace_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.modifyNamespace(args.namespaceDesc,resultHandler);
+ }
+ }
+
+ public static class deleteNamespace<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteNamespace_args, Void> {
+ public deleteNamespace() {
+ super("deleteNamespace");
+ }
+
+ public deleteNamespace_args getEmptyArgsInstance() {
+ return new deleteNamespace_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<Void> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<Void>() {
+ public void onComplete(Void o) {
+ deleteNamespace_result result = new deleteNamespace_result();
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ deleteNamespace_result result = new deleteNamespace_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, deleteNamespace_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws org.apache.thrift.TException {
+ iface.deleteNamespace(args.name,resultHandler);
+ }
+ }
+
+ public static class getNamespaceDescriptor<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getNamespaceDescriptor_args, TNamespaceDescriptor> {
+ public getNamespaceDescriptor() {
+ super("getNamespaceDescriptor");
+ }
+
+ public getNamespaceDescriptor_args getEmptyArgsInstance() {
+ return new getNamespaceDescriptor_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TNamespaceDescriptor> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TNamespaceDescriptor>() {
+ public void onComplete(TNamespaceDescriptor o) {
+ getNamespaceDescriptor_result result = new getNamespaceDescriptor_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getNamespaceDescriptor_result result = new getNamespaceDescriptor_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getNamespaceDescriptor_args args, org.apache.thrift.async.AsyncMethodCallback<TNamespaceDescriptor> resultHandler) throws org.apache.thrift.TException {
+ iface.getNamespaceDescriptor(args.name,resultHandler);
+ }
+ }
+
+ public static class listNamespaceDescriptors<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, listNamespaceDescriptors_args, java.util.List<TNamespaceDescriptor>> {
+ public listNamespaceDescriptors() {
+ super("listNamespaceDescriptors");
+ }
+
+ public listNamespaceDescriptors_args getEmptyArgsInstance() {
+ return new listNamespaceDescriptors_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TNamespaceDescriptor>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TNamespaceDescriptor>>() {
+ public void onComplete(java.util.List<TNamespaceDescriptor> o) {
+ listNamespaceDescriptors_result result = new listNamespaceDescriptors_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ listNamespaceDescriptors_result result = new listNamespaceDescriptors_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, listNamespaceDescriptors_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TNamespaceDescriptor>> resultHandler) throws org.apache.thrift.TException {
+ iface.listNamespaceDescriptors(resultHandler);
+ }
+ }
+
+ public static class listNamespaces<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, listNamespaces_args, java.util.List<java.lang.String>> {
+ public listNamespaces() {
+ super("listNamespaces");
+ }
+
+ public listNamespaces_args getEmptyArgsInstance() {
+ return new listNamespaces_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.String>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.String>>() {
+ public void onComplete(java.util.List<java.lang.String> o) {
+ listNamespaces_result result = new listNamespaces_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ listNamespaces_result result = new listNamespaces_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, listNamespaces_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.String>> resultHandler) throws org.apache.thrift.TException {
+ iface.listNamespaces(resultHandler);
+ }
+ }
+
+ public static class getThriftServerType<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getThriftServerType_args, TThriftServerType> {
+ public getThriftServerType() {
+ super("getThriftServerType");
+ }
+
+ public getThriftServerType_args getEmptyArgsInstance() {
+ return new getThriftServerType_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TThriftServerType>() {
+ public void onComplete(TThriftServerType o) {
+ getThriftServerType_result result = new getThriftServerType_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getThriftServerType_result result = new getThriftServerType_result();
+ if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getThriftServerType_args args, org.apache.thrift.async.AsyncMethodCallback<TThriftServerType> resultHandler) throws org.apache.thrift.TException {
+ iface.getThriftServerType(resultHandler);
+ }
+ }
+
+ public static class getClusterId<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getClusterId_args, java.lang.String> {
+ public getClusterId() {
+ super("getClusterId");
+ }
+
+ public getClusterId_args getEmptyArgsInstance() {
+ return new getClusterId_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.String> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.String>() {
+ public void onComplete(java.lang.String o) {
+ getClusterId_result result = new getClusterId_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getClusterId_result result = new getClusterId_result();
+ if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getClusterId_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.String> resultHandler) throws org.apache.thrift.TException {
+ iface.getClusterId(resultHandler);
+ }
+ }
+
+ public static class getSlowLogResponses<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getSlowLogResponses_args, java.util.List<TOnlineLogRecord>> {
+ public getSlowLogResponses() {
+ super("getSlowLogResponses");
+ }
+
+ public getSlowLogResponses_args getEmptyArgsInstance() {
+ return new getSlowLogResponses_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<TOnlineLogRecord>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<TOnlineLogRecord>>() {
+ public void onComplete(java.util.List<TOnlineLogRecord> o) {
+ getSlowLogResponses_result result = new getSlowLogResponses_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ getSlowLogResponses_result result = new getSlowLogResponses_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, getSlowLogResponses_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<TOnlineLogRecord>> resultHandler) throws org.apache.thrift.TException {
+ iface.getSlowLogResponses(args.serverNames, args.logQueryFilter,resultHandler);
+ }
+ }
+
+ public static class clearSlowLogResponses<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, clearSlowLogResponses_args, java.util.List<java.lang.Boolean>> {
+ public clearSlowLogResponses() {
+ super("clearSlowLogResponses");
+ }
+
+ public clearSlowLogResponses_args getEmptyArgsInstance() {
+ return new clearSlowLogResponses_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>>() {
+ public void onComplete(java.util.List<java.lang.Boolean> o) {
+ clearSlowLogResponses_result result = new clearSlowLogResponses_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ clearSlowLogResponses_result result = new clearSlowLogResponses_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, clearSlowLogResponses_args args, org.apache.thrift.async.AsyncMethodCallback<java.util.List<java.lang.Boolean>> resultHandler) throws org.apache.thrift.TException {
+ iface.clearSlowLogResponses(args.serverNames,resultHandler);
+ }
+ }
+
+ public static class grant<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, grant_args, java.lang.Boolean> {
+ public grant() {
+ super("grant");
+ }
+
+ public grant_args getEmptyArgsInstance() {
+ return new grant_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ grant_result result = new grant_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ grant_result result = new grant_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, grant_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.grant(args.info,resultHandler);
+ }
+ }
+
+ public static class revoke<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, revoke_args, java.lang.Boolean> {
+ public revoke() {
+ super("revoke");
+ }
+
+ public revoke_args getEmptyArgsInstance() {
+ return new revoke_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean>() {
+ public void onComplete(java.lang.Boolean o) {
+ revoke_result result = new revoke_result();
+ result.success = o;
+ result.setSuccessIsSet(true);
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ revoke_result result = new revoke_result();
+ if (e instanceof TIOError) {
+ result.io = (TIOError) e;
+ result.setIoIsSet(true);
+ msg = result;
+ } else if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, revoke_args args, org.apache.thrift.async.AsyncMethodCallback<java.lang.Boolean> resultHandler) throws org.apache.thrift.TException {
+ iface.revoke(args.info,resultHandler);
+ }
+ }
+
+ }
+
+ public static class exists_args implements org.apache.thrift.TBase<exists_args, exists_args._Fields>, java.io.Serializable, Cloneable, Comparable<exists_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TGET_FIELD_DESC = new org.apache.thrift.protocol.TField("tget", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new exists_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new exists_argsTupleSchemeFactory();
+
+ /**
+ * the table to check on
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the TGet to check for
+ */
+ public @org.apache.thrift.annotation.Nullable TGet tget; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to check on
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the TGet to check for
+ */
+ TGET((short)2, "tget");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TGET
+ return TGET;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TGET, new org.apache.thrift.meta_data.FieldMetaData("tget", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_args.class, metaDataMap);
+ }
+
+ public exists_args() {
+ }
+
+ public exists_args(
+ java.nio.ByteBuffer table,
+ TGet tget)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tget = tget;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public exists_args(exists_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTget()) {
+ this.tget = new TGet(other.tget);
+ }
+ }
+
+ public exists_args deepCopy() {
+ return new exists_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tget = null;
+ }
+
+ /**
+ * the table to check on
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to check on
+ */
+ public exists_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public exists_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the TGet to check for
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TGet getTget() {
+ return this.tget;
+ }
+
+ /**
+ * the TGet to check for
+ */
+ public exists_args setTget(@org.apache.thrift.annotation.Nullable TGet tget) {
+ this.tget = tget;
+ return this;
+ }
+
+ public void unsetTget() {
+ this.tget = null;
+ }
+
+ /** Returns true if field tget is set (has been assigned a value) and false otherwise */
+ public boolean isSetTget() {
+ return this.tget != null;
+ }
+
+ public void setTgetIsSet(boolean value) {
+ if (!value) {
+ this.tget = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TGET:
+ if (value == null) {
+ unsetTget();
+ } else {
+ setTget((TGet)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TGET:
+ return getTget();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TGET:
+ return isSetTget();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof exists_args)
+ return this.equals((exists_args)that);
+ return false;
+ }
+
+ public boolean equals(exists_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tget = true && this.isSetTget();
+ boolean that_present_tget = true && that.isSetTget();
+ if (this_present_tget || that_present_tget) {
+ if (!(this_present_tget && that_present_tget))
+ return false;
+ if (!this.tget.equals(that.tget))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTget()) ? 131071 : 524287);
+ if (isSetTget())
+ hashCode = hashCode * 8191 + tget.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(exists_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTget(), other.isSetTget());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTget()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tget, other.tget);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("exists_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tget:");
+ if (this.tget == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tget);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tget == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tget' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tget != null) {
+ tget.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class exists_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public exists_argsStandardScheme getScheme() {
+ return new exists_argsStandardScheme();
+ }
+ }
+
+ private static class exists_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<exists_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, exists_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TGET
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tget = new TGet();
+ struct.tget.read(iprot);
+ struct.setTgetIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, exists_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tget != null) {
+ oprot.writeFieldBegin(TGET_FIELD_DESC);
+ struct.tget.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class exists_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public exists_argsTupleScheme getScheme() {
+ return new exists_argsTupleScheme();
+ }
+ }
+
+ private static class exists_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<exists_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tget.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tget = new TGet();
+ struct.tget.read(iprot);
+ struct.setTgetIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class exists_result implements org.apache.thrift.TBase<exists_result, exists_result._Fields>, java.io.Serializable, Cloneable, Comparable<exists_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new exists_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new exists_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_result.class, metaDataMap);
+ }
+
+ public exists_result() {
+ }
+
+ public exists_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public exists_result(exists_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public exists_result deepCopy() {
+ return new exists_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public exists_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public exists_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof exists_result)
+ return this.equals((exists_result)that);
+ return false;
+ }
+
+ public boolean equals(exists_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(exists_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("exists_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class exists_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public exists_resultStandardScheme getScheme() {
+ return new exists_resultStandardScheme();
+ }
+ }
+
+ private static class exists_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<exists_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, exists_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, exists_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class exists_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public exists_resultTupleScheme getScheme() {
+ return new exists_resultTupleScheme();
+ }
+ }
+
+ private static class exists_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<exists_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class existsAll_args implements org.apache.thrift.TBase<existsAll_args, existsAll_args._Fields>, java.io.Serializable, Cloneable, Comparable<existsAll_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("existsAll_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TGETS_FIELD_DESC = new org.apache.thrift.protocol.TField("tgets", org.apache.thrift.protocol.TType.LIST, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new existsAll_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new existsAll_argsTupleSchemeFactory();
+
+ /**
+ * the table to check on
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * a list of TGets to check for
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<TGet> tgets; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to check on
+ */
+ TABLE((short)1, "table"),
+ /**
+ * a list of TGets to check for
+ */
+ TGETS((short)2, "tgets");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TGETS
+ return TGETS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TGETS, new org.apache.thrift.meta_data.FieldMetaData("tgets", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TGet.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(existsAll_args.class, metaDataMap);
+ }
+
+ public existsAll_args() {
+ }
+
+ public existsAll_args(
+ java.nio.ByteBuffer table,
+ java.util.List<TGet> tgets)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tgets = tgets;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public existsAll_args(existsAll_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTgets()) {
+ java.util.List<TGet> __this__tgets = new java.util.ArrayList<TGet>(other.tgets.size());
+ for (TGet other_element : other.tgets) {
+ __this__tgets.add(new TGet(other_element));
+ }
+ this.tgets = __this__tgets;
+ }
+ }
+
+ public existsAll_args deepCopy() {
+ return new existsAll_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tgets = null;
+ }
+
+ /**
+ * the table to check on
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to check on
+ */
+ public existsAll_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public existsAll_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public int getTgetsSize() {
+ return (this.tgets == null) ? 0 : this.tgets.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TGet> getTgetsIterator() {
+ return (this.tgets == null) ? null : this.tgets.iterator();
+ }
+
+ public void addToTgets(TGet elem) {
+ if (this.tgets == null) {
+ this.tgets = new java.util.ArrayList<TGet>();
+ }
+ this.tgets.add(elem);
+ }
+
+ /**
+ * a list of TGets to check for
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TGet> getTgets() {
+ return this.tgets;
+ }
+
+ /**
+ * a list of TGets to check for
+ */
+ public existsAll_args setTgets(@org.apache.thrift.annotation.Nullable java.util.List<TGet> tgets) {
+ this.tgets = tgets;
+ return this;
+ }
+
+ public void unsetTgets() {
+ this.tgets = null;
+ }
+
+ /** Returns true if field tgets is set (has been assigned a value) and false otherwise */
+ public boolean isSetTgets() {
+ return this.tgets != null;
+ }
+
+ public void setTgetsIsSet(boolean value) {
+ if (!value) {
+ this.tgets = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TGETS:
+ if (value == null) {
+ unsetTgets();
+ } else {
+ setTgets((java.util.List<TGet>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TGETS:
+ return getTgets();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TGETS:
+ return isSetTgets();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof existsAll_args)
+ return this.equals((existsAll_args)that);
+ return false;
+ }
+
+ public boolean equals(existsAll_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tgets = true && this.isSetTgets();
+ boolean that_present_tgets = true && that.isSetTgets();
+ if (this_present_tgets || that_present_tgets) {
+ if (!(this_present_tgets && that_present_tgets))
+ return false;
+ if (!this.tgets.equals(that.tgets))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTgets()) ? 131071 : 524287);
+ if (isSetTgets())
+ hashCode = hashCode * 8191 + tgets.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(existsAll_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTgets(), other.isSetTgets());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTgets()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tgets, other.tgets);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("existsAll_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tgets:");
+ if (this.tgets == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tgets);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tgets == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tgets' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class existsAll_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public existsAll_argsStandardScheme getScheme() {
+ return new existsAll_argsStandardScheme();
+ }
+ }
+
+ private static class existsAll_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<existsAll_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, existsAll_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TGETS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list190 = iprot.readListBegin();
+ struct.tgets = new java.util.ArrayList<TGet>(_list190.size);
+ @org.apache.thrift.annotation.Nullable TGet _elem191;
+ for (int _i192 = 0; _i192 < _list190.size; ++_i192)
+ {
+ _elem191 = new TGet();
+ _elem191.read(iprot);
+ struct.tgets.add(_elem191);
+ }
+ iprot.readListEnd();
+ }
+ struct.setTgetsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, existsAll_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tgets != null) {
+ oprot.writeFieldBegin(TGETS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.tgets.size()));
+ for (TGet _iter193 : struct.tgets)
+ {
+ _iter193.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class existsAll_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public existsAll_argsTupleScheme getScheme() {
+ return new existsAll_argsTupleScheme();
+ }
+ }
+
+ private static class existsAll_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<existsAll_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, existsAll_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ {
+ oprot.writeI32(struct.tgets.size());
+ for (TGet _iter194 : struct.tgets)
+ {
+ _iter194.write(oprot);
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, existsAll_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list195 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.tgets = new java.util.ArrayList<TGet>(_list195.size);
+ @org.apache.thrift.annotation.Nullable TGet _elem196;
+ for (int _i197 = 0; _i197 < _list195.size; ++_i197)
+ {
+ _elem196 = new TGet();
+ _elem196.read(iprot);
+ struct.tgets.add(_elem196);
+ }
+ }
+ struct.setTgetsIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class existsAll_result implements org.apache.thrift.TBase<existsAll_result, existsAll_result._Fields>, java.io.Serializable, Cloneable, Comparable<existsAll_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("existsAll_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new existsAll_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new existsAll_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.lang.Boolean> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(existsAll_result.class, metaDataMap);
+ }
+
+ public existsAll_result() {
+ }
+
+ public existsAll_result(
+ java.util.List<java.lang.Boolean> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public existsAll_result(existsAll_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<java.lang.Boolean> __this__success = new java.util.ArrayList<java.lang.Boolean>(other.success);
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public existsAll_result deepCopy() {
+ return new existsAll_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.lang.Boolean> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(boolean elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<java.lang.Boolean>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.lang.Boolean> getSuccess() {
+ return this.success;
+ }
+
+ public existsAll_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<java.lang.Boolean> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public existsAll_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<java.lang.Boolean>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof existsAll_result)
+ return this.equals((existsAll_result)that);
+ return false;
+ }
+
+ public boolean equals(existsAll_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(existsAll_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("existsAll_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class existsAll_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public existsAll_resultStandardScheme getScheme() {
+ return new existsAll_resultStandardScheme();
+ }
+ }
+
+ private static class existsAll_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<existsAll_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, existsAll_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list198 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<java.lang.Boolean>(_list198.size);
+ boolean _elem199;
+ for (int _i200 = 0; _i200 < _list198.size; ++_i200)
+ {
+ _elem199 = iprot.readBool();
+ struct.success.add(_elem199);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, existsAll_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.BOOL, struct.success.size()));
+ for (boolean _iter201 : struct.success)
+ {
+ oprot.writeBool(_iter201);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class existsAll_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public existsAll_resultTupleScheme getScheme() {
+ return new existsAll_resultTupleScheme();
+ }
+ }
+
+ private static class existsAll_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<existsAll_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, existsAll_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (boolean _iter202 : struct.success)
+ {
+ oprot.writeBool(_iter202);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, existsAll_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list203 = iprot.readListBegin(org.apache.thrift.protocol.TType.BOOL);
+ struct.success = new java.util.ArrayList<java.lang.Boolean>(_list203.size);
+ boolean _elem204;
+ for (int _i205 = 0; _i205 < _list203.size; ++_i205)
+ {
+ _elem204 = iprot.readBool();
+ struct.success.add(_elem204);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable, Comparable<get_args> {
+ 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_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TGET_FIELD_DESC = new org.apache.thrift.protocol.TField("tget", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new get_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new get_argsTupleSchemeFactory();
+
+ /**
+ * the table to get from
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the TGet to fetch
+ */
+ public @org.apache.thrift.annotation.Nullable TGet tget; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to get from
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the TGet to fetch
+ */
+ TGET((short)2, "tget");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TGET
+ return TGET;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TGET, new org.apache.thrift.meta_data.FieldMetaData("tget", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
+ }
+
+ public get_args() {
+ }
+
+ public get_args(
+ java.nio.ByteBuffer table,
+ TGet tget)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tget = tget;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public get_args(get_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTget()) {
+ this.tget = new TGet(other.tget);
+ }
+ }
+
+ public get_args deepCopy() {
+ return new get_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tget = null;
+ }
+
+ /**
+ * the table to get from
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to get from
+ */
+ public get_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public get_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the TGet to fetch
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TGet getTget() {
+ return this.tget;
+ }
+
+ /**
+ * the TGet to fetch
+ */
+ public get_args setTget(@org.apache.thrift.annotation.Nullable TGet tget) {
+ this.tget = tget;
+ return this;
+ }
+
+ public void unsetTget() {
+ this.tget = null;
+ }
+
+ /** Returns true if field tget is set (has been assigned a value) and false otherwise */
+ public boolean isSetTget() {
+ return this.tget != null;
+ }
+
+ public void setTgetIsSet(boolean value) {
+ if (!value) {
+ this.tget = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TGET:
+ if (value == null) {
+ unsetTget();
+ } else {
+ setTget((TGet)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TGET:
+ return getTget();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TGET:
+ return isSetTget();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof get_args)
+ return this.equals((get_args)that);
+ return false;
+ }
+
+ public boolean equals(get_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tget = true && this.isSetTget();
+ boolean that_present_tget = true && that.isSetTget();
+ if (this_present_tget || that_present_tget) {
+ if (!(this_present_tget && that_present_tget))
+ return false;
+ if (!this.tget.equals(that.tget))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTget()) ? 131071 : 524287);
+ if (isSetTget())
+ hashCode = hashCode * 8191 + tget.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(get_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTget(), other.isSetTget());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTget()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tget, other.tget);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("get_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tget:");
+ if (this.tget == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tget);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tget == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tget' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tget != null) {
+ tget.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class get_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_argsStandardScheme getScheme() {
+ return new get_argsStandardScheme();
+ }
+ }
+
+ private static class get_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<get_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TGET
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tget = new TGet();
+ struct.tget.read(iprot);
+ struct.setTgetIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tget != null) {
+ oprot.writeFieldBegin(TGET_FIELD_DESC);
+ struct.tget.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class get_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_argsTupleScheme getScheme() {
+ return new get_argsTupleScheme();
+ }
+ }
+
+ private static class get_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<get_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tget.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tget = new TGet();
+ struct.tget.read(iprot);
+ struct.setTgetIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable, Comparable<get_result> {
+ 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.STRUCT, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new get_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new get_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TResult success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
+ }
+
+ public get_result() {
+ }
+
+ public get_result(
+ TResult success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public get_result(get_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TResult(other.success);
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public get_result deepCopy() {
+ return new get_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TResult getSuccess() {
+ return this.success;
+ }
+
+ public get_result setSuccess(@org.apache.thrift.annotation.Nullable TResult success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public get_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TResult)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof get_result)
+ return this.equals((get_result)that);
+ return false;
+ }
+
+ public boolean equals(get_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(get_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("get_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class get_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_resultStandardScheme getScheme() {
+ return new get_resultStandardScheme();
+ }
+ }
+
+ private static class get_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<get_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TResult();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class get_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public get_resultTupleScheme getScheme() {
+ return new get_resultTupleScheme();
+ }
+ }
+
+ private static class get_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<get_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = new TResult();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getMultiple_args implements org.apache.thrift.TBase<getMultiple_args, getMultiple_args._Fields>, java.io.Serializable, Cloneable, Comparable<getMultiple_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TGETS_FIELD_DESC = new org.apache.thrift.protocol.TField("tgets", org.apache.thrift.protocol.TType.LIST, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getMultiple_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getMultiple_argsTupleSchemeFactory();
+
+ /**
+ * the table to get from
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * a list of TGets to fetch, the Result list
+ * will have the Results at corresponding positions
+ * or null if there was an error
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<TGet> tgets; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to get from
+ */
+ TABLE((short)1, "table"),
+ /**
+ * a list of TGets to fetch, the Result list
+ * will have the Results at corresponding positions
+ * or null if there was an error
+ */
+ TGETS((short)2, "tgets");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TGETS
+ return TGETS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TGETS, new org.apache.thrift.meta_data.FieldMetaData("tgets", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TGet.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_args.class, metaDataMap);
+ }
+
+ public getMultiple_args() {
+ }
+
+ public getMultiple_args(
+ java.nio.ByteBuffer table,
+ java.util.List<TGet> tgets)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tgets = tgets;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getMultiple_args(getMultiple_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTgets()) {
+ java.util.List<TGet> __this__tgets = new java.util.ArrayList<TGet>(other.tgets.size());
+ for (TGet other_element : other.tgets) {
+ __this__tgets.add(new TGet(other_element));
+ }
+ this.tgets = __this__tgets;
+ }
+ }
+
+ public getMultiple_args deepCopy() {
+ return new getMultiple_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tgets = null;
+ }
+
+ /**
+ * the table to get from
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to get from
+ */
+ public getMultiple_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public getMultiple_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public int getTgetsSize() {
+ return (this.tgets == null) ? 0 : this.tgets.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TGet> getTgetsIterator() {
+ return (this.tgets == null) ? null : this.tgets.iterator();
+ }
+
+ public void addToTgets(TGet elem) {
+ if (this.tgets == null) {
+ this.tgets = new java.util.ArrayList<TGet>();
+ }
+ this.tgets.add(elem);
+ }
+
+ /**
+ * a list of TGets to fetch, the Result list
+ * will have the Results at corresponding positions
+ * or null if there was an error
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TGet> getTgets() {
+ return this.tgets;
+ }
+
+ /**
+ * a list of TGets to fetch, the Result list
+ * will have the Results at corresponding positions
+ * or null if there was an error
+ */
+ public getMultiple_args setTgets(@org.apache.thrift.annotation.Nullable java.util.List<TGet> tgets) {
+ this.tgets = tgets;
+ return this;
+ }
+
+ public void unsetTgets() {
+ this.tgets = null;
+ }
+
+ /** Returns true if field tgets is set (has been assigned a value) and false otherwise */
+ public boolean isSetTgets() {
+ return this.tgets != null;
+ }
+
+ public void setTgetsIsSet(boolean value) {
+ if (!value) {
+ this.tgets = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TGETS:
+ if (value == null) {
+ unsetTgets();
+ } else {
+ setTgets((java.util.List<TGet>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TGETS:
+ return getTgets();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TGETS:
+ return isSetTgets();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getMultiple_args)
+ return this.equals((getMultiple_args)that);
+ return false;
+ }
+
+ public boolean equals(getMultiple_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tgets = true && this.isSetTgets();
+ boolean that_present_tgets = true && that.isSetTgets();
+ if (this_present_tgets || that_present_tgets) {
+ if (!(this_present_tgets && that_present_tgets))
+ return false;
+ if (!this.tgets.equals(that.tgets))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTgets()) ? 131071 : 524287);
+ if (isSetTgets())
+ hashCode = hashCode * 8191 + tgets.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getMultiple_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTgets(), other.isSetTgets());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTgets()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tgets, other.tgets);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getMultiple_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tgets:");
+ if (this.tgets == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tgets);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tgets == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tgets' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getMultiple_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getMultiple_argsStandardScheme getScheme() {
+ return new getMultiple_argsStandardScheme();
+ }
+ }
+
+ private static class getMultiple_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getMultiple_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TGETS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list206 = iprot.readListBegin();
+ struct.tgets = new java.util.ArrayList<TGet>(_list206.size);
+ @org.apache.thrift.annotation.Nullable TGet _elem207;
+ for (int _i208 = 0; _i208 < _list206.size; ++_i208)
+ {
+ _elem207 = new TGet();
+ _elem207.read(iprot);
+ struct.tgets.add(_elem207);
+ }
+ iprot.readListEnd();
+ }
+ struct.setTgetsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tgets != null) {
+ oprot.writeFieldBegin(TGETS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.tgets.size()));
+ for (TGet _iter209 : struct.tgets)
+ {
+ _iter209.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getMultiple_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getMultiple_argsTupleScheme getScheme() {
+ return new getMultiple_argsTupleScheme();
+ }
+ }
+
+ private static class getMultiple_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getMultiple_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ {
+ oprot.writeI32(struct.tgets.size());
+ for (TGet _iter210 : struct.tgets)
+ {
+ _iter210.write(oprot);
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list211 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.tgets = new java.util.ArrayList<TGet>(_list211.size);
+ @org.apache.thrift.annotation.Nullable TGet _elem212;
+ for (int _i213 = 0; _i213 < _list211.size; ++_i213)
+ {
+ _elem212 = new TGet();
+ _elem212.read(iprot);
+ struct.tgets.add(_elem212);
+ }
+ }
+ struct.setTgetsIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getMultiple_result implements org.apache.thrift.TBase<getMultiple_result, getMultiple_result._Fields>, java.io.Serializable, Cloneable, Comparable<getMultiple_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getMultiple_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getMultiple_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TResult> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_result.class, metaDataMap);
+ }
+
+ public getMultiple_result() {
+ }
+
+ public getMultiple_result(
+ java.util.List<TResult> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getMultiple_result(getMultiple_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TResult> __this__success = new java.util.ArrayList<TResult>(other.success.size());
+ for (TResult other_element : other.success) {
+ __this__success.add(new TResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getMultiple_result deepCopy() {
+ return new getMultiple_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TResult> getSuccess() {
+ return this.success;
+ }
+
+ public getMultiple_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getMultiple_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getMultiple_result)
+ return this.equals((getMultiple_result)that);
+ return false;
+ }
+
+ public boolean equals(getMultiple_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getMultiple_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getMultiple_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getMultiple_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getMultiple_resultStandardScheme getScheme() {
+ return new getMultiple_resultStandardScheme();
+ }
+ }
+
+ private static class getMultiple_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getMultiple_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list214 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TResult>(_list214.size);
+ @org.apache.thrift.annotation.Nullable TResult _elem215;
+ for (int _i216 = 0; _i216 < _list214.size; ++_i216)
+ {
+ _elem215 = new TResult();
+ _elem215.read(iprot);
+ struct.success.add(_elem215);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TResult _iter217 : struct.success)
+ {
+ _iter217.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getMultiple_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getMultiple_resultTupleScheme getScheme() {
+ return new getMultiple_resultTupleScheme();
+ }
+ }
+
+ private static class getMultiple_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getMultiple_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TResult _iter218 : struct.success)
+ {
+ _iter218.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list219 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TResult>(_list219.size);
+ @org.apache.thrift.annotation.Nullable TResult _elem220;
+ for (int _i221 = 0; _i221 < _list219.size; ++_i221)
+ {
+ _elem220 = new TResult();
+ _elem220.read(iprot);
+ struct.success.add(_elem220);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class put_args implements org.apache.thrift.TBase<put_args, put_args._Fields>, java.io.Serializable, Cloneable, Comparable<put_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TPUT_FIELD_DESC = new org.apache.thrift.protocol.TField("tput", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new put_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new put_argsTupleSchemeFactory();
+
+ /**
+ * the table to put data in
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the TPut to put
+ */
+ public @org.apache.thrift.annotation.Nullable TPut tput; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to put data in
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the TPut to put
+ */
+ TPUT((short)2, "tput");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TPUT
+ return TPUT;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TPUT, new org.apache.thrift.meta_data.FieldMetaData("tput", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_args.class, metaDataMap);
+ }
+
+ public put_args() {
+ }
+
+ public put_args(
+ java.nio.ByteBuffer table,
+ TPut tput)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tput = tput;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public put_args(put_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTput()) {
+ this.tput = new TPut(other.tput);
+ }
+ }
+
+ public put_args deepCopy() {
+ return new put_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tput = null;
+ }
+
+ /**
+ * the table to put data in
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to put data in
+ */
+ public put_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public put_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the TPut to put
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TPut getTput() {
+ return this.tput;
+ }
+
+ /**
+ * the TPut to put
+ */
+ public put_args setTput(@org.apache.thrift.annotation.Nullable TPut tput) {
+ this.tput = tput;
+ return this;
+ }
+
+ public void unsetTput() {
+ this.tput = null;
+ }
+
+ /** Returns true if field tput is set (has been assigned a value) and false otherwise */
+ public boolean isSetTput() {
+ return this.tput != null;
+ }
+
+ public void setTputIsSet(boolean value) {
+ if (!value) {
+ this.tput = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TPUT:
+ if (value == null) {
+ unsetTput();
+ } else {
+ setTput((TPut)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TPUT:
+ return getTput();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TPUT:
+ return isSetTput();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof put_args)
+ return this.equals((put_args)that);
+ return false;
+ }
+
+ public boolean equals(put_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tput = true && this.isSetTput();
+ boolean that_present_tput = true && that.isSetTput();
+ if (this_present_tput || that_present_tput) {
+ if (!(this_present_tput && that_present_tput))
+ return false;
+ if (!this.tput.equals(that.tput))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTput()) ? 131071 : 524287);
+ if (isSetTput())
+ hashCode = hashCode * 8191 + tput.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(put_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTput(), other.isSetTput());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTput()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tput, other.tput);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("put_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tput:");
+ if (this.tput == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tput);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tput == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tput' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tput != null) {
+ tput.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class put_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public put_argsStandardScheme getScheme() {
+ return new put_argsStandardScheme();
+ }
+ }
+
+ private static class put_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<put_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, put_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TPUT
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tput = new TPut();
+ struct.tput.read(iprot);
+ struct.setTputIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, put_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tput != null) {
+ oprot.writeFieldBegin(TPUT_FIELD_DESC);
+ struct.tput.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class put_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public put_argsTupleScheme getScheme() {
+ return new put_argsTupleScheme();
+ }
+ }
+
+ private static class put_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<put_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tput.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tput = new TPut();
+ struct.tput.read(iprot);
+ struct.setTputIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class put_result implements org.apache.thrift.TBase<put_result, put_result._Fields>, java.io.Serializable, Cloneable, Comparable<put_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new put_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new put_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_result.class, metaDataMap);
+ }
+
+ public put_result() {
+ }
+
+ public put_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public put_result(put_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public put_result deepCopy() {
+ return new put_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public put_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof put_result)
+ return this.equals((put_result)that);
+ return false;
+ }
+
+ public boolean equals(put_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(put_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("put_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class put_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public put_resultStandardScheme getScheme() {
+ return new put_resultStandardScheme();
+ }
+ }
+
+ private static class put_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<put_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, put_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, put_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class put_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public put_resultTupleScheme getScheme() {
+ return new put_resultTupleScheme();
+ }
+ }
+
+ private static class put_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<put_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndPut_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", 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 FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)5);
+ private static final org.apache.thrift.protocol.TField TPUT_FIELD_DESC = new org.apache.thrift.protocol.TField("tput", org.apache.thrift.protocol.TType.STRUCT, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndPut_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndPut_argsTupleSchemeFactory();
+
+ /**
+ * to check in and put to
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * row to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * column family to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family; // required
+ /**
+ * column qualifier to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier; // required
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value; // required
+ /**
+ * the TPut to put if the check succeeds
+ */
+ public @org.apache.thrift.annotation.Nullable TPut tput; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * to check in and put to
+ */
+ TABLE((short)1, "table"),
+ /**
+ * row to check
+ */
+ ROW((short)2, "row"),
+ /**
+ * column family to check
+ */
+ FAMILY((short)3, "family"),
+ /**
+ * column qualifier to check
+ */
+ QUALIFIER((short)4, "qualifier"),
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ VALUE((short)5, "value"),
+ /**
+ * the TPut to put if the check succeeds
+ */
+ TPUT((short)6, "tput");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // ROW
+ return ROW;
+ case 3: // FAMILY
+ return FAMILY;
+ case 4: // QUALIFIER
+ return QUALIFIER;
+ case 5: // VALUE
+ return VALUE;
+ case 6: // TPUT
+ return TPUT;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ 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.STRING , true)));
+ tmpMap.put(_Fields.TPUT, new org.apache.thrift.meta_data.FieldMetaData("tput", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
+ }
+
+ public checkAndPut_args() {
+ }
+
+ public checkAndPut_args(
+ java.nio.ByteBuffer table,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer family,
+ java.nio.ByteBuffer qualifier,
+ java.nio.ByteBuffer value,
+ TPut tput)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ this.tput = tput;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndPut_args(checkAndPut_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetFamily()) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
+ }
+ if (other.isSetQualifier()) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
+ }
+ if (other.isSetValue()) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
+ }
+ if (other.isSetTput()) {
+ this.tput = new TPut(other.tput);
+ }
+ }
+
+ public checkAndPut_args deepCopy() {
+ return new checkAndPut_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.row = null;
+ this.family = null;
+ this.qualifier = null;
+ this.value = null;
+ this.tput = null;
+ }
+
+ /**
+ * to check in and put to
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * to check in and put to
+ */
+ public checkAndPut_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public checkAndPut_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * row to check
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row to check
+ */
+ public checkAndPut_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public checkAndPut_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * column family to check
+ */
+ public byte[] getFamily() {
+ setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
+ return family == null ? null : family.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFamily() {
+ return org.apache.thrift.TBaseHelper.copyBinary(family);
+ }
+
+ /**
+ * column family to check
+ */
+ public checkAndPut_args setFamily(byte[] family) {
+ this.family = family == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(family.clone());
+ return this;
+ }
+
+ public checkAndPut_args setFamily(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ return this;
+ }
+
+ public void unsetFamily() {
+ this.family = null;
+ }
+
+ /** Returns true if field family is set (has been assigned a value) and false otherwise */
+ public boolean isSetFamily() {
+ return this.family != null;
+ }
+
+ public void setFamilyIsSet(boolean value) {
+ if (!value) {
+ this.family = null;
+ }
+ }
+
+ /**
+ * column qualifier to check
+ */
+ public byte[] getQualifier() {
+ setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
+ return qualifier == null ? null : qualifier.array();
+ }
+
+ public java.nio.ByteBuffer bufferForQualifier() {
+ return org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ /**
+ * column qualifier to check
+ */
+ public checkAndPut_args setQualifier(byte[] qualifier) {
+ this.qualifier = qualifier == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(qualifier.clone());
+ return this;
+ }
+
+ public checkAndPut_args setQualifier(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ return this;
+ }
+
+ public void unsetQualifier() {
+ this.qualifier = null;
+ }
+
+ /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
+ public boolean isSetQualifier() {
+ return this.qualifier != null;
+ }
+
+ public void setQualifierIsSet(boolean value) {
+ if (!value) {
+ this.qualifier = null;
+ }
+ }
+
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ public byte[] getValue() {
+ setValue(org.apache.thrift.TBaseHelper.rightSize(value));
+ return value == null ? null : value.array();
+ }
+
+ public java.nio.ByteBuffer bufferForValue() {
+ return org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ public checkAndPut_args setValue(byte[] value) {
+ this.value = value == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(value.clone());
+ return this;
+ }
+
+ public checkAndPut_args setValue(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ return this;
+ }
+
+ public void unsetValue() {
+ this.value = null;
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return this.value != null;
+ }
+
+ public void setValueIsSet(boolean value) {
+ if (!value) {
+ this.value = null;
+ }
+ }
+
+ /**
+ * the TPut to put if the check succeeds
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TPut getTput() {
+ return this.tput;
+ }
+
+ /**
+ * the TPut to put if the check succeeds
+ */
+ public checkAndPut_args setTput(@org.apache.thrift.annotation.Nullable TPut tput) {
+ this.tput = tput;
+ return this;
+ }
+
+ public void unsetTput() {
+ this.tput = null;
+ }
+
+ /** Returns true if field tput is set (has been assigned a value) and false otherwise */
+ public boolean isSetTput() {
+ return this.tput != null;
+ }
+
+ public void setTputIsSet(boolean value) {
+ if (!value) {
+ this.tput = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case FAMILY:
+ if (value == null) {
+ unsetFamily();
+ } else {
+ if (value instanceof byte[]) {
+ setFamily((byte[])value);
+ } else {
+ setFamily((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case QUALIFIER:
+ if (value == null) {
+ unsetQualifier();
+ } else {
+ if (value instanceof byte[]) {
+ setQualifier((byte[])value);
+ } else {
+ setQualifier((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ if (value instanceof byte[]) {
+ setValue((byte[])value);
+ } else {
+ setValue((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TPUT:
+ if (value == null) {
+ unsetTput();
+ } else {
+ setTput((TPut)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case ROW:
+ return getRow();
+
+ case FAMILY:
+ return getFamily();
+
+ case QUALIFIER:
+ return getQualifier();
+
+ case VALUE:
+ return getValue();
+
+ case TPUT:
+ return getTput();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case ROW:
+ return isSetRow();
+ case FAMILY:
+ return isSetFamily();
+ case QUALIFIER:
+ return isSetQualifier();
+ case VALUE:
+ return isSetValue();
+ case TPUT:
+ return isSetTput();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndPut_args)
+ return this.equals((checkAndPut_args)that);
+ return false;
+ }
+
+ public boolean equals(checkAndPut_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_family = true && this.isSetFamily();
+ boolean that_present_family = true && that.isSetFamily();
+ if (this_present_family || that_present_family) {
+ if (!(this_present_family && that_present_family))
+ return false;
+ if (!this.family.equals(that.family))
+ return false;
+ }
+
+ boolean this_present_qualifier = true && this.isSetQualifier();
+ boolean that_present_qualifier = true && that.isSetQualifier();
+ if (this_present_qualifier || that_present_qualifier) {
+ if (!(this_present_qualifier && that_present_qualifier))
+ return false;
+ if (!this.qualifier.equals(that.qualifier))
+ return false;
+ }
+
+ boolean this_present_value = true && this.isSetValue();
+ boolean that_present_value = true && that.isSetValue();
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (!this.value.equals(that.value))
+ return false;
+ }
+
+ boolean this_present_tput = true && this.isSetTput();
+ boolean that_present_tput = true && that.isSetTput();
+ if (this_present_tput || that_present_tput) {
+ if (!(this_present_tput && that_present_tput))
+ return false;
+ if (!this.tput.equals(that.tput))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetFamily()) ? 131071 : 524287);
+ if (isSetFamily())
+ hashCode = hashCode * 8191 + family.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetQualifier()) ? 131071 : 524287);
+ if (isSetQualifier())
+ hashCode = hashCode * 8191 + qualifier.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetValue()) ? 131071 : 524287);
+ if (isSetValue())
+ hashCode = hashCode * 8191 + value.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTput()) ? 131071 : 524287);
+ if (isSetTput())
+ hashCode = hashCode * 8191 + tput.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndPut_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFamily(), other.isSetFamily());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFamily()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, other.family);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQualifier(), other.isSetQualifier());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQualifier()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, other.qualifier);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTput(), other.isSetTput());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTput()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tput, other.tput);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndPut_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("family:");
+ if (this.family == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.family, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("qualifier:");
+ if (this.qualifier == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("value:");
+ if (this.value == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.value, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tput:");
+ if (this.tput == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tput);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ if (family == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
+ }
+ if (qualifier == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
+ }
+ if (tput == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tput' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tput != null) {
+ tput.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndPut_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_argsStandardScheme getScheme() {
+ return new checkAndPut_argsStandardScheme();
+ }
+ }
+
+ private static class checkAndPut_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndPut_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // FAMILY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // QUALIFIER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // TPUT
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tput = new TPut();
+ struct.tput.read(iprot);
+ struct.setTputIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.family != null) {
+ oprot.writeFieldBegin(FAMILY_FIELD_DESC);
+ oprot.writeBinary(struct.family);
+ oprot.writeFieldEnd();
+ }
+ if (struct.qualifier != null) {
+ oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeFieldEnd();
+ }
+ if (struct.value != null) {
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeBinary(struct.value);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tput != null) {
+ oprot.writeFieldBegin(TPUT_FIELD_DESC);
+ struct.tput.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndPut_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_argsTupleScheme getScheme() {
+ return new checkAndPut_argsTupleScheme();
+ }
+ }
+
+ private static class checkAndPut_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndPut_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ oprot.writeBinary(struct.row);
+ oprot.writeBinary(struct.family);
+ oprot.writeBinary(struct.qualifier);
+ struct.tput.write(oprot);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetValue()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetValue()) {
+ oprot.writeBinary(struct.value);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ struct.tput = new TPut();
+ struct.tput.read(iprot);
+ struct.setTputIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndPut_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndPut_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndPut_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
+ }
+
+ public checkAndPut_result() {
+ }
+
+ public checkAndPut_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndPut_result(checkAndPut_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public checkAndPut_result deepCopy() {
+ return new checkAndPut_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public checkAndPut_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public checkAndPut_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndPut_result)
+ return this.equals((checkAndPut_result)that);
+ return false;
+ }
+
+ public boolean equals(checkAndPut_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndPut_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndPut_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndPut_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_resultStandardScheme getScheme() {
+ return new checkAndPut_resultStandardScheme();
+ }
+ }
+
+ private static class checkAndPut_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndPut_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndPut_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndPut_resultTupleScheme getScheme() {
+ return new checkAndPut_resultTupleScheme();
+ }
+ }
+
+ private static class checkAndPut_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndPut_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class putMultiple_args implements org.apache.thrift.TBase<putMultiple_args, putMultiple_args._Fields>, java.io.Serializable, Cloneable, Comparable<putMultiple_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TPUTS_FIELD_DESC = new org.apache.thrift.protocol.TField("tputs", org.apache.thrift.protocol.TType.LIST, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new putMultiple_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new putMultiple_argsTupleSchemeFactory();
+
+ /**
+ * the table to put data in
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * a list of TPuts to commit
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<TPut> tputs; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to put data in
+ */
+ TABLE((short)1, "table"),
+ /**
+ * a list of TPuts to commit
+ */
+ TPUTS((short)2, "tputs");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TPUTS
+ return TPUTS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TPUTS, new org.apache.thrift.meta_data.FieldMetaData("tputs", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TPut.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_args.class, metaDataMap);
+ }
+
+ public putMultiple_args() {
+ }
+
+ public putMultiple_args(
+ java.nio.ByteBuffer table,
+ java.util.List<TPut> tputs)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tputs = tputs;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public putMultiple_args(putMultiple_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTputs()) {
+ java.util.List<TPut> __this__tputs = new java.util.ArrayList<TPut>(other.tputs.size());
+ for (TPut other_element : other.tputs) {
+ __this__tputs.add(new TPut(other_element));
+ }
+ this.tputs = __this__tputs;
+ }
+ }
+
+ public putMultiple_args deepCopy() {
+ return new putMultiple_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tputs = null;
+ }
+
+ /**
+ * the table to put data in
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to put data in
+ */
+ public putMultiple_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public putMultiple_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public int getTputsSize() {
+ return (this.tputs == null) ? 0 : this.tputs.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TPut> getTputsIterator() {
+ return (this.tputs == null) ? null : this.tputs.iterator();
+ }
+
+ public void addToTputs(TPut elem) {
+ if (this.tputs == null) {
+ this.tputs = new java.util.ArrayList<TPut>();
+ }
+ this.tputs.add(elem);
+ }
+
+ /**
+ * a list of TPuts to commit
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TPut> getTputs() {
+ return this.tputs;
+ }
+
+ /**
+ * a list of TPuts to commit
+ */
+ public putMultiple_args setTputs(@org.apache.thrift.annotation.Nullable java.util.List<TPut> tputs) {
+ this.tputs = tputs;
+ return this;
+ }
+
+ public void unsetTputs() {
+ this.tputs = null;
+ }
+
+ /** Returns true if field tputs is set (has been assigned a value) and false otherwise */
+ public boolean isSetTputs() {
+ return this.tputs != null;
+ }
+
+ public void setTputsIsSet(boolean value) {
+ if (!value) {
+ this.tputs = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TPUTS:
+ if (value == null) {
+ unsetTputs();
+ } else {
+ setTputs((java.util.List<TPut>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TPUTS:
+ return getTputs();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TPUTS:
+ return isSetTputs();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof putMultiple_args)
+ return this.equals((putMultiple_args)that);
+ return false;
+ }
+
+ public boolean equals(putMultiple_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tputs = true && this.isSetTputs();
+ boolean that_present_tputs = true && that.isSetTputs();
+ if (this_present_tputs || that_present_tputs) {
+ if (!(this_present_tputs && that_present_tputs))
+ return false;
+ if (!this.tputs.equals(that.tputs))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTputs()) ? 131071 : 524287);
+ if (isSetTputs())
+ hashCode = hashCode * 8191 + tputs.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(putMultiple_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTputs(), other.isSetTputs());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTputs()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tputs, other.tputs);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("putMultiple_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tputs:");
+ if (this.tputs == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tputs);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tputs == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tputs' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class putMultiple_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public putMultiple_argsStandardScheme getScheme() {
+ return new putMultiple_argsStandardScheme();
+ }
+ }
+
+ private static class putMultiple_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<putMultiple_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TPUTS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list222 = iprot.readListBegin();
+ struct.tputs = new java.util.ArrayList<TPut>(_list222.size);
+ @org.apache.thrift.annotation.Nullable TPut _elem223;
+ for (int _i224 = 0; _i224 < _list222.size; ++_i224)
+ {
+ _elem223 = new TPut();
+ _elem223.read(iprot);
+ struct.tputs.add(_elem223);
+ }
+ iprot.readListEnd();
+ }
+ struct.setTputsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tputs != null) {
+ oprot.writeFieldBegin(TPUTS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.tputs.size()));
+ for (TPut _iter225 : struct.tputs)
+ {
+ _iter225.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class putMultiple_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public putMultiple_argsTupleScheme getScheme() {
+ return new putMultiple_argsTupleScheme();
+ }
+ }
+
+ private static class putMultiple_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<putMultiple_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ {
+ oprot.writeI32(struct.tputs.size());
+ for (TPut _iter226 : struct.tputs)
+ {
+ _iter226.write(oprot);
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list227 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.tputs = new java.util.ArrayList<TPut>(_list227.size);
+ @org.apache.thrift.annotation.Nullable TPut _elem228;
+ for (int _i229 = 0; _i229 < _list227.size; ++_i229)
+ {
+ _elem228 = new TPut();
+ _elem228.read(iprot);
+ struct.tputs.add(_elem228);
+ }
+ }
+ struct.setTputsIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class putMultiple_result implements org.apache.thrift.TBase<putMultiple_result, putMultiple_result._Fields>, java.io.Serializable, Cloneable, Comparable<putMultiple_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new putMultiple_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new putMultiple_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_result.class, metaDataMap);
+ }
+
+ public putMultiple_result() {
+ }
+
+ public putMultiple_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public putMultiple_result(putMultiple_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public putMultiple_result deepCopy() {
+ return new putMultiple_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public putMultiple_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof putMultiple_result)
+ return this.equals((putMultiple_result)that);
+ return false;
+ }
+
+ public boolean equals(putMultiple_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(putMultiple_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("putMultiple_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class putMultiple_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public putMultiple_resultStandardScheme getScheme() {
+ return new putMultiple_resultStandardScheme();
+ }
+ }
+
+ private static class putMultiple_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<putMultiple_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class putMultiple_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public putMultiple_resultTupleScheme getScheme() {
+ return new putMultiple_resultTupleScheme();
+ }
+ }
+
+ private static class putMultiple_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<putMultiple_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteSingle_args implements org.apache.thrift.TBase<deleteSingle_args, deleteSingle_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteSingle_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TDELETE_FIELD_DESC = new org.apache.thrift.protocol.TField("tdelete", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteSingle_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteSingle_argsTupleSchemeFactory();
+
+ /**
+ * the table to delete from
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the TDelete to delete
+ */
+ public @org.apache.thrift.annotation.Nullable TDelete tdelete; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to delete from
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the TDelete to delete
+ */
+ TDELETE((short)2, "tdelete");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TDELETE
+ return TDELETE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TDELETE, new org.apache.thrift.meta_data.FieldMetaData("tdelete", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_args.class, metaDataMap);
+ }
+
+ public deleteSingle_args() {
+ }
+
+ public deleteSingle_args(
+ java.nio.ByteBuffer table,
+ TDelete tdelete)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tdelete = tdelete;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteSingle_args(deleteSingle_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTdelete()) {
+ this.tdelete = new TDelete(other.tdelete);
+ }
+ }
+
+ public deleteSingle_args deepCopy() {
+ return new deleteSingle_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tdelete = null;
+ }
+
+ /**
+ * the table to delete from
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to delete from
+ */
+ public deleteSingle_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public deleteSingle_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the TDelete to delete
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDelete getTdelete() {
+ return this.tdelete;
+ }
+
+ /**
+ * the TDelete to delete
+ */
+ public deleteSingle_args setTdelete(@org.apache.thrift.annotation.Nullable TDelete tdelete) {
+ this.tdelete = tdelete;
+ return this;
+ }
+
+ public void unsetTdelete() {
+ this.tdelete = null;
+ }
+
+ /** Returns true if field tdelete is set (has been assigned a value) and false otherwise */
+ public boolean isSetTdelete() {
+ return this.tdelete != null;
+ }
+
+ public void setTdeleteIsSet(boolean value) {
+ if (!value) {
+ this.tdelete = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TDELETE:
+ if (value == null) {
+ unsetTdelete();
+ } else {
+ setTdelete((TDelete)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TDELETE:
+ return getTdelete();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TDELETE:
+ return isSetTdelete();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteSingle_args)
+ return this.equals((deleteSingle_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteSingle_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tdelete = true && this.isSetTdelete();
+ boolean that_present_tdelete = true && that.isSetTdelete();
+ if (this_present_tdelete || that_present_tdelete) {
+ if (!(this_present_tdelete && that_present_tdelete))
+ return false;
+ if (!this.tdelete.equals(that.tdelete))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTdelete()) ? 131071 : 524287);
+ if (isSetTdelete())
+ hashCode = hashCode * 8191 + tdelete.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteSingle_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTdelete(), other.isSetTdelete());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTdelete()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tdelete, other.tdelete);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteSingle_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tdelete:");
+ if (this.tdelete == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tdelete);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tdelete == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tdelete' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tdelete != null) {
+ tdelete.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteSingle_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteSingle_argsStandardScheme getScheme() {
+ return new deleteSingle_argsStandardScheme();
+ }
+ }
+
+ private static class deleteSingle_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteSingle_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TDELETE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tdelete = new TDelete();
+ struct.tdelete.read(iprot);
+ struct.setTdeleteIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tdelete != null) {
+ oprot.writeFieldBegin(TDELETE_FIELD_DESC);
+ struct.tdelete.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteSingle_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteSingle_argsTupleScheme getScheme() {
+ return new deleteSingle_argsTupleScheme();
+ }
+ }
+
+ private static class deleteSingle_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteSingle_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tdelete.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tdelete = new TDelete();
+ struct.tdelete.read(iprot);
+ struct.setTdeleteIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteSingle_result implements org.apache.thrift.TBase<deleteSingle_result, deleteSingle_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteSingle_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteSingle_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteSingle_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_result.class, metaDataMap);
+ }
+
+ public deleteSingle_result() {
+ }
+
+ public deleteSingle_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteSingle_result(deleteSingle_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public deleteSingle_result deepCopy() {
+ return new deleteSingle_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public deleteSingle_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteSingle_result)
+ return this.equals((deleteSingle_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteSingle_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteSingle_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteSingle_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteSingle_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteSingle_resultStandardScheme getScheme() {
+ return new deleteSingle_resultStandardScheme();
+ }
+ }
+
+ private static class deleteSingle_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteSingle_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteSingle_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteSingle_resultTupleScheme getScheme() {
+ return new deleteSingle_resultTupleScheme();
+ }
+ }
+
+ private static class deleteSingle_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteSingle_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteMultiple_args implements org.apache.thrift.TBase<deleteMultiple_args, deleteMultiple_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteMultiple_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TDELETES_FIELD_DESC = new org.apache.thrift.protocol.TField("tdeletes", org.apache.thrift.protocol.TType.LIST, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteMultiple_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteMultiple_argsTupleSchemeFactory();
+
+ /**
+ * the table to delete from
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * list of TDeletes to delete
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<TDelete> tdeletes; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to delete from
+ */
+ TABLE((short)1, "table"),
+ /**
+ * list of TDeletes to delete
+ */
+ TDELETES((short)2, "tdeletes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TDELETES
+ return TDELETES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TDELETES, new org.apache.thrift.meta_data.FieldMetaData("tdeletes", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TDelete.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_args.class, metaDataMap);
+ }
+
+ public deleteMultiple_args() {
+ }
+
+ public deleteMultiple_args(
+ java.nio.ByteBuffer table,
+ java.util.List<TDelete> tdeletes)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tdeletes = tdeletes;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteMultiple_args(deleteMultiple_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTdeletes()) {
+ java.util.List<TDelete> __this__tdeletes = new java.util.ArrayList<TDelete>(other.tdeletes.size());
+ for (TDelete other_element : other.tdeletes) {
+ __this__tdeletes.add(new TDelete(other_element));
+ }
+ this.tdeletes = __this__tdeletes;
+ }
+ }
+
+ public deleteMultiple_args deepCopy() {
+ return new deleteMultiple_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tdeletes = null;
+ }
+
+ /**
+ * the table to delete from
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to delete from
+ */
+ public deleteMultiple_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public deleteMultiple_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public int getTdeletesSize() {
+ return (this.tdeletes == null) ? 0 : this.tdeletes.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TDelete> getTdeletesIterator() {
+ return (this.tdeletes == null) ? null : this.tdeletes.iterator();
+ }
+
+ public void addToTdeletes(TDelete elem) {
+ if (this.tdeletes == null) {
+ this.tdeletes = new java.util.ArrayList<TDelete>();
+ }
+ this.tdeletes.add(elem);
+ }
+
+ /**
+ * list of TDeletes to delete
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TDelete> getTdeletes() {
+ return this.tdeletes;
+ }
+
+ /**
+ * list of TDeletes to delete
+ */
+ public deleteMultiple_args setTdeletes(@org.apache.thrift.annotation.Nullable java.util.List<TDelete> tdeletes) {
+ this.tdeletes = tdeletes;
+ return this;
+ }
+
+ public void unsetTdeletes() {
+ this.tdeletes = null;
+ }
+
+ /** Returns true if field tdeletes is set (has been assigned a value) and false otherwise */
+ public boolean isSetTdeletes() {
+ return this.tdeletes != null;
+ }
+
+ public void setTdeletesIsSet(boolean value) {
+ if (!value) {
+ this.tdeletes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TDELETES:
+ if (value == null) {
+ unsetTdeletes();
+ } else {
+ setTdeletes((java.util.List<TDelete>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TDELETES:
+ return getTdeletes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TDELETES:
+ return isSetTdeletes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteMultiple_args)
+ return this.equals((deleteMultiple_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteMultiple_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tdeletes = true && this.isSetTdeletes();
+ boolean that_present_tdeletes = true && that.isSetTdeletes();
+ if (this_present_tdeletes || that_present_tdeletes) {
+ if (!(this_present_tdeletes && that_present_tdeletes))
+ return false;
+ if (!this.tdeletes.equals(that.tdeletes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTdeletes()) ? 131071 : 524287);
+ if (isSetTdeletes())
+ hashCode = hashCode * 8191 + tdeletes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteMultiple_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTdeletes(), other.isSetTdeletes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTdeletes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tdeletes, other.tdeletes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteMultiple_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tdeletes:");
+ if (this.tdeletes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tdeletes);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tdeletes == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tdeletes' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteMultiple_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteMultiple_argsStandardScheme getScheme() {
+ return new deleteMultiple_argsStandardScheme();
+ }
+ }
+
+ private static class deleteMultiple_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteMultiple_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TDELETES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list230 = iprot.readListBegin();
+ struct.tdeletes = new java.util.ArrayList<TDelete>(_list230.size);
+ @org.apache.thrift.annotation.Nullable TDelete _elem231;
+ for (int _i232 = 0; _i232 < _list230.size; ++_i232)
+ {
+ _elem231 = new TDelete();
+ _elem231.read(iprot);
+ struct.tdeletes.add(_elem231);
+ }
+ iprot.readListEnd();
+ }
+ struct.setTdeletesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tdeletes != null) {
+ oprot.writeFieldBegin(TDELETES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.tdeletes.size()));
+ for (TDelete _iter233 : struct.tdeletes)
+ {
+ _iter233.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteMultiple_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteMultiple_argsTupleScheme getScheme() {
+ return new deleteMultiple_argsTupleScheme();
+ }
+ }
+
+ private static class deleteMultiple_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteMultiple_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ {
+ oprot.writeI32(struct.tdeletes.size());
+ for (TDelete _iter234 : struct.tdeletes)
+ {
+ _iter234.write(oprot);
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list235 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.tdeletes = new java.util.ArrayList<TDelete>(_list235.size);
+ @org.apache.thrift.annotation.Nullable TDelete _elem236;
+ for (int _i237 = 0; _i237 < _list235.size; ++_i237)
+ {
+ _elem236 = new TDelete();
+ _elem236.read(iprot);
+ struct.tdeletes.add(_elem236);
+ }
+ }
+ struct.setTdeletesIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteMultiple_result implements org.apache.thrift.TBase<deleteMultiple_result, deleteMultiple_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteMultiple_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteMultiple_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteMultiple_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TDelete> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_result.class, metaDataMap);
+ }
+
+ public deleteMultiple_result() {
+ }
+
+ public deleteMultiple_result(
+ java.util.List<TDelete> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteMultiple_result(deleteMultiple_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TDelete> __this__success = new java.util.ArrayList<TDelete>(other.success.size());
+ for (TDelete other_element : other.success) {
+ __this__success.add(new TDelete(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public deleteMultiple_result deepCopy() {
+ return new deleteMultiple_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TDelete> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TDelete elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TDelete>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TDelete> getSuccess() {
+ return this.success;
+ }
+
+ public deleteMultiple_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TDelete> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public deleteMultiple_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TDelete>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteMultiple_result)
+ return this.equals((deleteMultiple_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteMultiple_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteMultiple_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteMultiple_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteMultiple_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteMultiple_resultStandardScheme getScheme() {
+ return new deleteMultiple_resultStandardScheme();
+ }
+ }
+
+ private static class deleteMultiple_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteMultiple_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list238 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TDelete>(_list238.size);
+ @org.apache.thrift.annotation.Nullable TDelete _elem239;
+ for (int _i240 = 0; _i240 < _list238.size; ++_i240)
+ {
+ _elem239 = new TDelete();
+ _elem239.read(iprot);
+ struct.success.add(_elem239);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TDelete _iter241 : struct.success)
+ {
+ _iter241.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteMultiple_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteMultiple_resultTupleScheme getScheme() {
+ return new deleteMultiple_resultTupleScheme();
+ }
+ }
+
+ private static class deleteMultiple_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteMultiple_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TDelete _iter242 : struct.success)
+ {
+ _iter242.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list243 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TDelete>(_list243.size);
+ @org.apache.thrift.annotation.Nullable TDelete _elem244;
+ for (int _i245 = 0; _i245 < _list243.size; ++_i245)
+ {
+ _elem244 = new TDelete();
+ _elem244.read(iprot);
+ struct.success.add(_elem244);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndDelete_args implements org.apache.thrift.TBase<checkAndDelete_args, checkAndDelete_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndDelete_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", 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 FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)5);
+ private static final org.apache.thrift.protocol.TField TDELETE_FIELD_DESC = new org.apache.thrift.protocol.TField("tdelete", org.apache.thrift.protocol.TType.STRUCT, (short)6);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndDelete_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndDelete_argsTupleSchemeFactory();
+
+ /**
+ * to check in and delete from
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * row to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * column family to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family; // required
+ /**
+ * column qualifier to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier; // required
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value; // required
+ /**
+ * the TDelete to execute if the check succeeds
+ */
+ public @org.apache.thrift.annotation.Nullable TDelete tdelete; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * to check in and delete from
+ */
+ TABLE((short)1, "table"),
+ /**
+ * row to check
+ */
+ ROW((short)2, "row"),
+ /**
+ * column family to check
+ */
+ FAMILY((short)3, "family"),
+ /**
+ * column qualifier to check
+ */
+ QUALIFIER((short)4, "qualifier"),
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ VALUE((short)5, "value"),
+ /**
+ * the TDelete to execute if the check succeeds
+ */
+ TDELETE((short)6, "tdelete");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // ROW
+ return ROW;
+ case 3: // FAMILY
+ return FAMILY;
+ case 4: // QUALIFIER
+ return QUALIFIER;
+ case 5: // VALUE
+ return VALUE;
+ case 6: // TDELETE
+ return TDELETE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ 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.STRING , true)));
+ tmpMap.put(_Fields.TDELETE, new org.apache.thrift.meta_data.FieldMetaData("tdelete", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_args.class, metaDataMap);
+ }
+
+ public checkAndDelete_args() {
+ }
+
+ public checkAndDelete_args(
+ java.nio.ByteBuffer table,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer family,
+ java.nio.ByteBuffer qualifier,
+ java.nio.ByteBuffer value,
+ TDelete tdelete)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ this.tdelete = tdelete;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndDelete_args(checkAndDelete_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetFamily()) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
+ }
+ if (other.isSetQualifier()) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
+ }
+ if (other.isSetValue()) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
+ }
+ if (other.isSetTdelete()) {
+ this.tdelete = new TDelete(other.tdelete);
+ }
+ }
+
+ public checkAndDelete_args deepCopy() {
+ return new checkAndDelete_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.row = null;
+ this.family = null;
+ this.qualifier = null;
+ this.value = null;
+ this.tdelete = null;
+ }
+
+ /**
+ * to check in and delete from
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * to check in and delete from
+ */
+ public checkAndDelete_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public checkAndDelete_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * row to check
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row to check
+ */
+ public checkAndDelete_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public checkAndDelete_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * column family to check
+ */
+ public byte[] getFamily() {
+ setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
+ return family == null ? null : family.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFamily() {
+ return org.apache.thrift.TBaseHelper.copyBinary(family);
+ }
+
+ /**
+ * column family to check
+ */
+ public checkAndDelete_args setFamily(byte[] family) {
+ this.family = family == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(family.clone());
+ return this;
+ }
+
+ public checkAndDelete_args setFamily(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ return this;
+ }
+
+ public void unsetFamily() {
+ this.family = null;
+ }
+
+ /** Returns true if field family is set (has been assigned a value) and false otherwise */
+ public boolean isSetFamily() {
+ return this.family != null;
+ }
+
+ public void setFamilyIsSet(boolean value) {
+ if (!value) {
+ this.family = null;
+ }
+ }
+
+ /**
+ * column qualifier to check
+ */
+ public byte[] getQualifier() {
+ setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
+ return qualifier == null ? null : qualifier.array();
+ }
+
+ public java.nio.ByteBuffer bufferForQualifier() {
+ return org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ /**
+ * column qualifier to check
+ */
+ public checkAndDelete_args setQualifier(byte[] qualifier) {
+ this.qualifier = qualifier == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(qualifier.clone());
+ return this;
+ }
+
+ public checkAndDelete_args setQualifier(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ return this;
+ }
+
+ public void unsetQualifier() {
+ this.qualifier = null;
+ }
+
+ /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
+ public boolean isSetQualifier() {
+ return this.qualifier != null;
+ }
+
+ public void setQualifierIsSet(boolean value) {
+ if (!value) {
+ this.qualifier = null;
+ }
+ }
+
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ public byte[] getValue() {
+ setValue(org.apache.thrift.TBaseHelper.rightSize(value));
+ return value == null ? null : value.array();
+ }
+
+ public java.nio.ByteBuffer bufferForValue() {
+ return org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ /**
+ * the expected value, if not provided the
+ * check is for the non-existence of the
+ * column in question
+ */
+ public checkAndDelete_args setValue(byte[] value) {
+ this.value = value == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(value.clone());
+ return this;
+ }
+
+ public checkAndDelete_args setValue(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ return this;
+ }
+
+ public void unsetValue() {
+ this.value = null;
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return this.value != null;
+ }
+
+ public void setValueIsSet(boolean value) {
+ if (!value) {
+ this.value = null;
+ }
+ }
+
+ /**
+ * the TDelete to execute if the check succeeds
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDelete getTdelete() {
+ return this.tdelete;
+ }
+
+ /**
+ * the TDelete to execute if the check succeeds
+ */
+ public checkAndDelete_args setTdelete(@org.apache.thrift.annotation.Nullable TDelete tdelete) {
+ this.tdelete = tdelete;
+ return this;
+ }
+
+ public void unsetTdelete() {
+ this.tdelete = null;
+ }
+
+ /** Returns true if field tdelete is set (has been assigned a value) and false otherwise */
+ public boolean isSetTdelete() {
+ return this.tdelete != null;
+ }
+
+ public void setTdeleteIsSet(boolean value) {
+ if (!value) {
+ this.tdelete = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case FAMILY:
+ if (value == null) {
+ unsetFamily();
+ } else {
+ if (value instanceof byte[]) {
+ setFamily((byte[])value);
+ } else {
+ setFamily((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case QUALIFIER:
+ if (value == null) {
+ unsetQualifier();
+ } else {
+ if (value instanceof byte[]) {
+ setQualifier((byte[])value);
+ } else {
+ setQualifier((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ if (value instanceof byte[]) {
+ setValue((byte[])value);
+ } else {
+ setValue((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TDELETE:
+ if (value == null) {
+ unsetTdelete();
+ } else {
+ setTdelete((TDelete)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case ROW:
+ return getRow();
+
+ case FAMILY:
+ return getFamily();
+
+ case QUALIFIER:
+ return getQualifier();
+
+ case VALUE:
+ return getValue();
+
+ case TDELETE:
+ return getTdelete();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case ROW:
+ return isSetRow();
+ case FAMILY:
+ return isSetFamily();
+ case QUALIFIER:
+ return isSetQualifier();
+ case VALUE:
+ return isSetValue();
+ case TDELETE:
+ return isSetTdelete();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndDelete_args)
+ return this.equals((checkAndDelete_args)that);
+ return false;
+ }
+
+ public boolean equals(checkAndDelete_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_family = true && this.isSetFamily();
+ boolean that_present_family = true && that.isSetFamily();
+ if (this_present_family || that_present_family) {
+ if (!(this_present_family && that_present_family))
+ return false;
+ if (!this.family.equals(that.family))
+ return false;
+ }
+
+ boolean this_present_qualifier = true && this.isSetQualifier();
+ boolean that_present_qualifier = true && that.isSetQualifier();
+ if (this_present_qualifier || that_present_qualifier) {
+ if (!(this_present_qualifier && that_present_qualifier))
+ return false;
+ if (!this.qualifier.equals(that.qualifier))
+ return false;
+ }
+
+ boolean this_present_value = true && this.isSetValue();
+ boolean that_present_value = true && that.isSetValue();
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (!this.value.equals(that.value))
+ return false;
+ }
+
+ boolean this_present_tdelete = true && this.isSetTdelete();
+ boolean that_present_tdelete = true && that.isSetTdelete();
+ if (this_present_tdelete || that_present_tdelete) {
+ if (!(this_present_tdelete && that_present_tdelete))
+ return false;
+ if (!this.tdelete.equals(that.tdelete))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetFamily()) ? 131071 : 524287);
+ if (isSetFamily())
+ hashCode = hashCode * 8191 + family.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetQualifier()) ? 131071 : 524287);
+ if (isSetQualifier())
+ hashCode = hashCode * 8191 + qualifier.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetValue()) ? 131071 : 524287);
+ if (isSetValue())
+ hashCode = hashCode * 8191 + value.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTdelete()) ? 131071 : 524287);
+ if (isSetTdelete())
+ hashCode = hashCode * 8191 + tdelete.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndDelete_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFamily(), other.isSetFamily());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFamily()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, other.family);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQualifier(), other.isSetQualifier());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQualifier()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, other.qualifier);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTdelete(), other.isSetTdelete());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTdelete()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tdelete, other.tdelete);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndDelete_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("family:");
+ if (this.family == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.family, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("qualifier:");
+ if (this.qualifier == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("value:");
+ if (this.value == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.value, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tdelete:");
+ if (this.tdelete == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tdelete);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ if (family == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
+ }
+ if (qualifier == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
+ }
+ if (tdelete == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tdelete' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tdelete != null) {
+ tdelete.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndDelete_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndDelete_argsStandardScheme getScheme() {
+ return new checkAndDelete_argsStandardScheme();
+ }
+ }
+
+ private static class checkAndDelete_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndDelete_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // FAMILY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // QUALIFIER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // TDELETE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tdelete = new TDelete();
+ struct.tdelete.read(iprot);
+ struct.setTdeleteIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.family != null) {
+ oprot.writeFieldBegin(FAMILY_FIELD_DESC);
+ oprot.writeBinary(struct.family);
+ oprot.writeFieldEnd();
+ }
+ if (struct.qualifier != null) {
+ oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeFieldEnd();
+ }
+ if (struct.value != null) {
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeBinary(struct.value);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tdelete != null) {
+ oprot.writeFieldBegin(TDELETE_FIELD_DESC);
+ struct.tdelete.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndDelete_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndDelete_argsTupleScheme getScheme() {
+ return new checkAndDelete_argsTupleScheme();
+ }
+ }
+
+ private static class checkAndDelete_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndDelete_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ oprot.writeBinary(struct.row);
+ oprot.writeBinary(struct.family);
+ oprot.writeBinary(struct.qualifier);
+ struct.tdelete.write(oprot);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetValue()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetValue()) {
+ oprot.writeBinary(struct.value);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ struct.tdelete = new TDelete();
+ struct.tdelete.read(iprot);
+ struct.setTdeleteIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndDelete_result implements org.apache.thrift.TBase<checkAndDelete_result, checkAndDelete_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndDelete_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndDelete_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndDelete_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_result.class, metaDataMap);
+ }
+
+ public checkAndDelete_result() {
+ }
+
+ public checkAndDelete_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndDelete_result(checkAndDelete_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public checkAndDelete_result deepCopy() {
+ return new checkAndDelete_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public checkAndDelete_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public checkAndDelete_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndDelete_result)
+ return this.equals((checkAndDelete_result)that);
+ return false;
+ }
+
+ public boolean equals(checkAndDelete_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndDelete_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndDelete_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndDelete_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndDelete_resultStandardScheme getScheme() {
+ return new checkAndDelete_resultStandardScheme();
+ }
+ }
+
+ private static class checkAndDelete_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndDelete_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndDelete_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndDelete_resultTupleScheme getScheme() {
+ return new checkAndDelete_resultTupleScheme();
+ }
+ }
+
+ private static class checkAndDelete_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndDelete_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class increment_args implements org.apache.thrift.TBase<increment_args, increment_args._Fields>, java.io.Serializable, Cloneable, Comparable<increment_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TINCREMENT_FIELD_DESC = new org.apache.thrift.protocol.TField("tincrement", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new increment_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new increment_argsTupleSchemeFactory();
+
+ /**
+ * the table to increment the value on
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the TIncrement to increment
+ */
+ public @org.apache.thrift.annotation.Nullable TIncrement tincrement; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to increment the value on
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the TIncrement to increment
+ */
+ TINCREMENT((short)2, "tincrement");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TINCREMENT
+ return TINCREMENT;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TINCREMENT, new org.apache.thrift.meta_data.FieldMetaData("tincrement", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIncrement.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_args.class, metaDataMap);
+ }
+
+ public increment_args() {
+ }
+
+ public increment_args(
+ java.nio.ByteBuffer table,
+ TIncrement tincrement)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tincrement = tincrement;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public increment_args(increment_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTincrement()) {
+ this.tincrement = new TIncrement(other.tincrement);
+ }
+ }
+
+ public increment_args deepCopy() {
+ return new increment_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tincrement = null;
+ }
+
+ /**
+ * the table to increment the value on
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to increment the value on
+ */
+ public increment_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public increment_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the TIncrement to increment
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TIncrement getTincrement() {
+ return this.tincrement;
+ }
+
+ /**
+ * the TIncrement to increment
+ */
+ public increment_args setTincrement(@org.apache.thrift.annotation.Nullable TIncrement tincrement) {
+ this.tincrement = tincrement;
+ return this;
+ }
+
+ public void unsetTincrement() {
+ this.tincrement = null;
+ }
+
+ /** Returns true if field tincrement is set (has been assigned a value) and false otherwise */
+ public boolean isSetTincrement() {
+ return this.tincrement != null;
+ }
+
+ public void setTincrementIsSet(boolean value) {
+ if (!value) {
+ this.tincrement = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TINCREMENT:
+ if (value == null) {
+ unsetTincrement();
+ } else {
+ setTincrement((TIncrement)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TINCREMENT:
+ return getTincrement();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TINCREMENT:
+ return isSetTincrement();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof increment_args)
+ return this.equals((increment_args)that);
+ return false;
+ }
+
+ public boolean equals(increment_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tincrement = true && this.isSetTincrement();
+ boolean that_present_tincrement = true && that.isSetTincrement();
+ if (this_present_tincrement || that_present_tincrement) {
+ if (!(this_present_tincrement && that_present_tincrement))
+ return false;
+ if (!this.tincrement.equals(that.tincrement))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTincrement()) ? 131071 : 524287);
+ if (isSetTincrement())
+ hashCode = hashCode * 8191 + tincrement.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(increment_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTincrement(), other.isSetTincrement());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTincrement()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tincrement, other.tincrement);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("increment_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tincrement:");
+ if (this.tincrement == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tincrement);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tincrement == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tincrement' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tincrement != null) {
+ tincrement.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class increment_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_argsStandardScheme getScheme() {
+ return new increment_argsStandardScheme();
+ }
+ }
+
+ private static class increment_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<increment_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, increment_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TINCREMENT
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tincrement = new TIncrement();
+ struct.tincrement.read(iprot);
+ struct.setTincrementIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, increment_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tincrement != null) {
+ oprot.writeFieldBegin(TINCREMENT_FIELD_DESC);
+ struct.tincrement.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class increment_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_argsTupleScheme getScheme() {
+ return new increment_argsTupleScheme();
+ }
+ }
+
+ private static class increment_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<increment_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tincrement.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tincrement = new TIncrement();
+ struct.tincrement.read(iprot);
+ struct.setTincrementIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class increment_result implements org.apache.thrift.TBase<increment_result, increment_result._Fields>, java.io.Serializable, Cloneable, Comparable<increment_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new increment_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new increment_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TResult success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_result.class, metaDataMap);
+ }
+
+ public increment_result() {
+ }
+
+ public increment_result(
+ TResult success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public increment_result(increment_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TResult(other.success);
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public increment_result deepCopy() {
+ return new increment_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TResult getSuccess() {
+ return this.success;
+ }
+
+ public increment_result setSuccess(@org.apache.thrift.annotation.Nullable TResult success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public increment_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TResult)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof increment_result)
+ return this.equals((increment_result)that);
+ return false;
+ }
+
+ public boolean equals(increment_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(increment_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("increment_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class increment_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_resultStandardScheme getScheme() {
+ return new increment_resultStandardScheme();
+ }
+ }
+
+ private static class increment_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<increment_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, increment_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TResult();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, increment_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class increment_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public increment_resultTupleScheme getScheme() {
+ return new increment_resultTupleScheme();
+ }
+ }
+
+ private static class increment_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<increment_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = new TResult();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class append_args implements org.apache.thrift.TBase<append_args, append_args._Fields>, java.io.Serializable, Cloneable, Comparable<append_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("append_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TAPPEND_FIELD_DESC = new org.apache.thrift.protocol.TField("tappend", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new append_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new append_argsTupleSchemeFactory();
+
+ /**
+ * the table to append the value on
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the TAppend to append
+ */
+ public @org.apache.thrift.annotation.Nullable TAppend tappend; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to append the value on
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the TAppend to append
+ */
+ TAPPEND((short)2, "tappend");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TAPPEND
+ return TAPPEND;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TAPPEND, new org.apache.thrift.meta_data.FieldMetaData("tappend", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAppend.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(append_args.class, metaDataMap);
+ }
+
+ public append_args() {
+ }
+
+ public append_args(
+ java.nio.ByteBuffer table,
+ TAppend tappend)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tappend = tappend;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public append_args(append_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTappend()) {
+ this.tappend = new TAppend(other.tappend);
+ }
+ }
+
+ public append_args deepCopy() {
+ return new append_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tappend = null;
+ }
+
+ /**
+ * the table to append the value on
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to append the value on
+ */
+ public append_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public append_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the TAppend to append
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TAppend getTappend() {
+ return this.tappend;
+ }
+
+ /**
+ * the TAppend to append
+ */
+ public append_args setTappend(@org.apache.thrift.annotation.Nullable TAppend tappend) {
+ this.tappend = tappend;
+ return this;
+ }
+
+ public void unsetTappend() {
+ this.tappend = null;
+ }
+
+ /** Returns true if field tappend is set (has been assigned a value) and false otherwise */
+ public boolean isSetTappend() {
+ return this.tappend != null;
+ }
+
+ public void setTappendIsSet(boolean value) {
+ if (!value) {
+ this.tappend = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TAPPEND:
+ if (value == null) {
+ unsetTappend();
+ } else {
+ setTappend((TAppend)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TAPPEND:
+ return getTappend();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TAPPEND:
+ return isSetTappend();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof append_args)
+ return this.equals((append_args)that);
+ return false;
+ }
+
+ public boolean equals(append_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tappend = true && this.isSetTappend();
+ boolean that_present_tappend = true && that.isSetTappend();
+ if (this_present_tappend || that_present_tappend) {
+ if (!(this_present_tappend && that_present_tappend))
+ return false;
+ if (!this.tappend.equals(that.tappend))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTappend()) ? 131071 : 524287);
+ if (isSetTappend())
+ hashCode = hashCode * 8191 + tappend.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(append_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTappend(), other.isSetTappend());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTappend()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tappend, other.tappend);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("append_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tappend:");
+ if (this.tappend == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tappend);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tappend == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tappend' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tappend != null) {
+ tappend.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class append_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_argsStandardScheme getScheme() {
+ return new append_argsStandardScheme();
+ }
+ }
+
+ private static class append_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<append_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, append_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TAPPEND
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tappend = new TAppend();
+ struct.tappend.read(iprot);
+ struct.setTappendIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, append_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tappend != null) {
+ oprot.writeFieldBegin(TAPPEND_FIELD_DESC);
+ struct.tappend.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class append_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_argsTupleScheme getScheme() {
+ return new append_argsTupleScheme();
+ }
+ }
+
+ private static class append_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<append_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, append_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tappend.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, append_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tappend = new TAppend();
+ struct.tappend.read(iprot);
+ struct.setTappendIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class append_result implements org.apache.thrift.TBase<append_result, append_result._Fields>, java.io.Serializable, Cloneable, Comparable<append_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("append_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new append_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new append_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TResult success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(append_result.class, metaDataMap);
+ }
+
+ public append_result() {
+ }
+
+ public append_result(
+ TResult success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public append_result(append_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TResult(other.success);
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public append_result deepCopy() {
+ return new append_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TResult getSuccess() {
+ return this.success;
+ }
+
+ public append_result setSuccess(@org.apache.thrift.annotation.Nullable TResult success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public append_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TResult)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof append_result)
+ return this.equals((append_result)that);
+ return false;
+ }
+
+ public boolean equals(append_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(append_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("append_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class append_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_resultStandardScheme getScheme() {
+ return new append_resultStandardScheme();
+ }
+ }
+
+ private static class append_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<append_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, append_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TResult();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, append_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class append_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public append_resultTupleScheme getScheme() {
+ return new append_resultTupleScheme();
+ }
+ }
+
+ private static class append_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<append_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, append_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, append_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = new TResult();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class openScanner_args implements org.apache.thrift.TBase<openScanner_args, openScanner_args._Fields>, java.io.Serializable, Cloneable, Comparable<openScanner_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TSCAN_FIELD_DESC = new org.apache.thrift.protocol.TField("tscan", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new openScanner_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new openScanner_argsTupleSchemeFactory();
+
+ /**
+ * the table to get the Scanner for
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the scan object to get a Scanner for
+ */
+ public @org.apache.thrift.annotation.Nullable TScan tscan; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to get the Scanner for
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the scan object to get a Scanner for
+ */
+ TSCAN((short)2, "tscan");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TSCAN
+ return TSCAN;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TSCAN, new org.apache.thrift.meta_data.FieldMetaData("tscan", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_args.class, metaDataMap);
+ }
+
+ public openScanner_args() {
+ }
+
+ public openScanner_args(
+ java.nio.ByteBuffer table,
+ TScan tscan)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tscan = tscan;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public openScanner_args(openScanner_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTscan()) {
+ this.tscan = new TScan(other.tscan);
+ }
+ }
+
+ public openScanner_args deepCopy() {
+ return new openScanner_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tscan = null;
+ }
+
+ /**
+ * the table to get the Scanner for
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to get the Scanner for
+ */
+ public openScanner_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public openScanner_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the scan object to get a Scanner for
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TScan getTscan() {
+ return this.tscan;
+ }
+
+ /**
+ * the scan object to get a Scanner for
+ */
+ public openScanner_args setTscan(@org.apache.thrift.annotation.Nullable TScan tscan) {
+ this.tscan = tscan;
+ return this;
+ }
+
+ public void unsetTscan() {
+ this.tscan = null;
+ }
+
+ /** Returns true if field tscan is set (has been assigned a value) and false otherwise */
+ public boolean isSetTscan() {
+ return this.tscan != null;
+ }
+
+ public void setTscanIsSet(boolean value) {
+ if (!value) {
+ this.tscan = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TSCAN:
+ if (value == null) {
+ unsetTscan();
+ } else {
+ setTscan((TScan)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TSCAN:
+ return getTscan();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TSCAN:
+ return isSetTscan();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof openScanner_args)
+ return this.equals((openScanner_args)that);
+ return false;
+ }
+
+ public boolean equals(openScanner_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tscan = true && this.isSetTscan();
+ boolean that_present_tscan = true && that.isSetTscan();
+ if (this_present_tscan || that_present_tscan) {
+ if (!(this_present_tscan && that_present_tscan))
+ return false;
+ if (!this.tscan.equals(that.tscan))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTscan()) ? 131071 : 524287);
+ if (isSetTscan())
+ hashCode = hashCode * 8191 + tscan.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(openScanner_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTscan(), other.isSetTscan());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTscan()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tscan, other.tscan);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("openScanner_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tscan:");
+ if (this.tscan == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tscan);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tscan == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tscan' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tscan != null) {
+ tscan.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class openScanner_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public openScanner_argsStandardScheme getScheme() {
+ return new openScanner_argsStandardScheme();
+ }
+ }
+
+ private static class openScanner_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<openScanner_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TSCAN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tscan = new TScan();
+ struct.tscan.read(iprot);
+ struct.setTscanIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tscan != null) {
+ oprot.writeFieldBegin(TSCAN_FIELD_DESC);
+ struct.tscan.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class openScanner_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public openScanner_argsTupleScheme getScheme() {
+ return new openScanner_argsTupleScheme();
+ }
+ }
+
+ private static class openScanner_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<openScanner_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tscan.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tscan = new TScan();
+ struct.tscan.read(iprot);
+ struct.setTscanIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class openScanner_result implements org.apache.thrift.TBase<openScanner_result, openScanner_result._Fields>, java.io.Serializable, Cloneable, Comparable<openScanner_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new openScanner_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new openScanner_resultTupleSchemeFactory();
+
+ public int success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_result.class, metaDataMap);
+ }
+
+ public openScanner_result() {
+ }
+
+ public openScanner_result(
+ int success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public openScanner_result(openScanner_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public openScanner_result deepCopy() {
+ return new openScanner_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = 0;
+ this.io = null;
+ }
+
+ public int getSuccess() {
+ return this.success;
+ }
+
+ public openScanner_result setSuccess(int success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public openScanner_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Integer)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof openScanner_result)
+ return this.equals((openScanner_result)that);
+ return false;
+ }
+
+ public boolean equals(openScanner_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + success;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(openScanner_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("openScanner_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class openScanner_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public openScanner_resultStandardScheme getScheme() {
+ return new openScanner_resultStandardScheme();
+ }
+ }
+
+ private static class openScanner_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<openScanner_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class openScanner_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public openScanner_resultTupleScheme getScheme() {
+ return new openScanner_resultTupleScheme();
+ }
+ }
+
+ private static class openScanner_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<openScanner_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readI32();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getScannerRows_args implements org.apache.thrift.TBase<getScannerRows_args, getScannerRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<getScannerRows_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_args");
+
+ private static final org.apache.thrift.protocol.TField SCANNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scannerId", org.apache.thrift.protocol.TType.I32, (short)1);
+ private static final org.apache.thrift.protocol.TField NUM_ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("numRows", org.apache.thrift.protocol.TType.I32, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getScannerRows_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getScannerRows_argsTupleSchemeFactory();
+
+ /**
+ * the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+ */
+ public int scannerId; // required
+ /**
+ * number of rows to return
+ */
+ public int numRows; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+ */
+ SCANNER_ID((short)1, "scannerId"),
+ /**
+ * number of rows to return
+ */
+ NUM_ROWS((short)2, "numRows");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // SCANNER_ID
+ return SCANNER_ID;
+ case 2: // NUM_ROWS
+ return NUM_ROWS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SCANNERID_ISSET_ID = 0;
+ private static final int __NUMROWS_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_args.class, metaDataMap);
+ }
+
+ public getScannerRows_args() {
+ this.numRows = 1;
+
+ }
+
+ public getScannerRows_args(
+ int scannerId,
+ int numRows)
+ {
+ this();
+ this.scannerId = scannerId;
+ setScannerIdIsSet(true);
+ this.numRows = numRows;
+ setNumRowsIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getScannerRows_args(getScannerRows_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.scannerId = other.scannerId;
+ this.numRows = other.numRows;
+ }
+
+ public getScannerRows_args deepCopy() {
+ return new getScannerRows_args(this);
+ }
+
+ @Override
+ public void clear() {
+ setScannerIdIsSet(false);
+ this.scannerId = 0;
+ this.numRows = 1;
+
+ }
+
+ /**
+ * the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+ */
+ public int getScannerId() {
+ return this.scannerId;
+ }
+
+ /**
+ * the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+ */
+ public getScannerRows_args setScannerId(int scannerId) {
+ this.scannerId = scannerId;
+ setScannerIdIsSet(true);
+ return this;
+ }
+
+ public void unsetScannerId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SCANNERID_ISSET_ID);
+ }
+
+ /** Returns true if field scannerId is set (has been assigned a value) and false otherwise */
+ public boolean isSetScannerId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SCANNERID_ISSET_ID);
+ }
+
+ public void setScannerIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SCANNERID_ISSET_ID, value);
+ }
+
+ /**
+ * number of rows to return
+ */
+ public int getNumRows() {
+ return this.numRows;
+ }
+
+ /**
+ * number of rows to return
+ */
+ public getScannerRows_args setNumRows(int numRows) {
+ this.numRows = numRows;
+ setNumRowsIsSet(true);
+ return this;
+ }
+
+ public void unsetNumRows() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __NUMROWS_ISSET_ID);
+ }
+
+ /** Returns true if field numRows is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumRows() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __NUMROWS_ISSET_ID);
+ }
+
+ public void setNumRowsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __NUMROWS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SCANNER_ID:
+ if (value == null) {
+ unsetScannerId();
+ } else {
+ setScannerId((java.lang.Integer)value);
+ }
+ break;
+
+ case NUM_ROWS:
+ if (value == null) {
+ unsetNumRows();
+ } else {
+ setNumRows((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SCANNER_ID:
+ return getScannerId();
+
+ case NUM_ROWS:
+ return getNumRows();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SCANNER_ID:
+ return isSetScannerId();
+ case NUM_ROWS:
+ return isSetNumRows();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getScannerRows_args)
+ return this.equals((getScannerRows_args)that);
+ return false;
+ }
+
+ public boolean equals(getScannerRows_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_scannerId = true;
+ boolean that_present_scannerId = true;
+ if (this_present_scannerId || that_present_scannerId) {
+ if (!(this_present_scannerId && that_present_scannerId))
+ return false;
+ if (this.scannerId != that.scannerId)
+ return false;
+ }
+
+ boolean this_present_numRows = true;
+ boolean that_present_numRows = true;
+ if (this_present_numRows || that_present_numRows) {
+ if (!(this_present_numRows && that_present_numRows))
+ return false;
+ if (this.numRows != that.numRows)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + scannerId;
+
+ hashCode = hashCode * 8191 + numRows;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getScannerRows_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetScannerId(), other.isSetScannerId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetScannerId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, other.scannerId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetNumRows(), other.isSetNumRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNumRows()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, other.numRows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getScannerRows_args(");
+ boolean first = true;
+
+ sb.append("scannerId:");
+ sb.append(this.scannerId);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("numRows:");
+ sb.append(this.numRows);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // alas, we cannot check 'scannerId' because it's a primitive and you chose the non-beans generator.
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getScannerRows_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerRows_argsStandardScheme getScheme() {
+ return new getScannerRows_argsStandardScheme();
+ }
+ }
+
+ private static class getScannerRows_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getScannerRows_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // SCANNER_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.scannerId = iprot.readI32();
+ struct.setScannerIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // NUM_ROWS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.numRows = iprot.readI32();
+ struct.setNumRowsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetScannerId()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
+ oprot.writeI32(struct.scannerId);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
+ oprot.writeI32(struct.numRows);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getScannerRows_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerRows_argsTupleScheme getScheme() {
+ return new getScannerRows_argsTupleScheme();
+ }
+ }
+
+ private static class getScannerRows_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getScannerRows_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeI32(struct.scannerId);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetNumRows()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetNumRows()) {
+ oprot.writeI32(struct.numRows);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.scannerId = iprot.readI32();
+ struct.setScannerIdIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.numRows = iprot.readI32();
+ struct.setNumRowsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getScannerRows_result implements org.apache.thrift.TBase<getScannerRows_result, getScannerRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<getScannerRows_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getScannerRows_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getScannerRows_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TResult> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+ /**
+ * if the scannerId is invalid
+ */
+ public @org.apache.thrift.annotation.Nullable TIllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io"),
+ /**
+ * if the scannerId is invalid
+ */
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_result.class, metaDataMap);
+ }
+
+ public getScannerRows_result() {
+ }
+
+ public getScannerRows_result(
+ java.util.List<TResult> success,
+ TIOError io,
+ TIllegalArgument ia)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getScannerRows_result(getScannerRows_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TResult> __this__success = new java.util.ArrayList<TResult>(other.success.size());
+ for (TResult other_element : other.success) {
+ __this__success.add(new TResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new TIllegalArgument(other.ia);
+ }
+ }
+
+ public getScannerRows_result deepCopy() {
+ return new getScannerRows_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ this.ia = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TResult> getSuccess() {
+ return this.success;
+ }
+
+ public getScannerRows_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getScannerRows_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ /**
+ * if the scannerId is invalid
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TIllegalArgument getIa() {
+ return this.ia;
+ }
+
+ /**
+ * if the scannerId is invalid
+ */
+ public getScannerRows_result setIa(@org.apache.thrift.annotation.Nullable TIllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((TIllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getScannerRows_result)
+ return this.equals((getScannerRows_result)that);
+ return false;
+ }
+
+ public boolean equals(getScannerRows_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getScannerRows_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getScannerRows_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getScannerRows_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerRows_resultStandardScheme getScheme() {
+ return new getScannerRows_resultStandardScheme();
+ }
+ }
+
+ private static class getScannerRows_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getScannerRows_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list246 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TResult>(_list246.size);
+ @org.apache.thrift.annotation.Nullable TResult _elem247;
+ for (int _i248 = 0; _i248 < _list246.size; ++_i248)
+ {
+ _elem247 = new TResult();
+ _elem247.read(iprot);
+ struct.success.add(_elem247);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new TIllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TResult _iter249 : struct.success)
+ {
+ _iter249.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getScannerRows_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerRows_resultTupleScheme getScheme() {
+ return new getScannerRows_resultTupleScheme();
+ }
+ }
+
+ private static class getScannerRows_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getScannerRows_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TResult _iter250 : struct.success)
+ {
+ _iter250.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list251 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TResult>(_list251.size);
+ @org.apache.thrift.annotation.Nullable TResult _elem252;
+ for (int _i253 = 0; _i253 < _list251.size; ++_i253)
+ {
+ _elem252 = new TResult();
+ _elem252.read(iprot);
+ struct.success.add(_elem252);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.ia = new TIllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class closeScanner_args implements org.apache.thrift.TBase<closeScanner_args, closeScanner_args._Fields>, java.io.Serializable, Cloneable, Comparable<closeScanner_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_args");
+
+ private static final org.apache.thrift.protocol.TField SCANNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scannerId", org.apache.thrift.protocol.TType.I32, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new closeScanner_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new closeScanner_argsTupleSchemeFactory();
+
+ /**
+ * the Id of the Scanner to close *
+ */
+ public int scannerId; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the Id of the Scanner to close *
+ */
+ SCANNER_ID((short)1, "scannerId");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // SCANNER_ID
+ return SCANNER_ID;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SCANNERID_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_args.class, metaDataMap);
+ }
+
+ public closeScanner_args() {
+ }
+
+ public closeScanner_args(
+ int scannerId)
+ {
+ this();
+ this.scannerId = scannerId;
+ setScannerIdIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public closeScanner_args(closeScanner_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.scannerId = other.scannerId;
+ }
+
+ public closeScanner_args deepCopy() {
+ return new closeScanner_args(this);
+ }
+
+ @Override
+ public void clear() {
+ setScannerIdIsSet(false);
+ this.scannerId = 0;
+ }
+
+ /**
+ * the Id of the Scanner to close *
+ */
+ public int getScannerId() {
+ return this.scannerId;
+ }
+
+ /**
+ * the Id of the Scanner to close *
+ */
+ public closeScanner_args setScannerId(int scannerId) {
+ this.scannerId = scannerId;
+ setScannerIdIsSet(true);
+ return this;
+ }
+
+ public void unsetScannerId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SCANNERID_ISSET_ID);
+ }
+
+ /** Returns true if field scannerId is set (has been assigned a value) and false otherwise */
+ public boolean isSetScannerId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SCANNERID_ISSET_ID);
+ }
+
+ public void setScannerIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SCANNERID_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SCANNER_ID:
+ if (value == null) {
+ unsetScannerId();
+ } else {
+ setScannerId((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SCANNER_ID:
+ return getScannerId();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SCANNER_ID:
+ return isSetScannerId();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof closeScanner_args)
+ return this.equals((closeScanner_args)that);
+ return false;
+ }
+
+ public boolean equals(closeScanner_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_scannerId = true;
+ boolean that_present_scannerId = true;
+ if (this_present_scannerId || that_present_scannerId) {
+ if (!(this_present_scannerId && that_present_scannerId))
+ return false;
+ if (this.scannerId != that.scannerId)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + scannerId;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(closeScanner_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetScannerId(), other.isSetScannerId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetScannerId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, other.scannerId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("closeScanner_args(");
+ boolean first = true;
+
+ sb.append("scannerId:");
+ sb.append(this.scannerId);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // alas, we cannot check 'scannerId' because it's a primitive and you chose the non-beans generator.
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class closeScanner_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public closeScanner_argsStandardScheme getScheme() {
+ return new closeScanner_argsStandardScheme();
+ }
+ }
+
+ private static class closeScanner_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<closeScanner_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // SCANNER_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.scannerId = iprot.readI32();
+ struct.setScannerIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetScannerId()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
+ oprot.writeI32(struct.scannerId);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class closeScanner_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public closeScanner_argsTupleScheme getScheme() {
+ return new closeScanner_argsTupleScheme();
+ }
+ }
+
+ private static class closeScanner_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<closeScanner_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeI32(struct.scannerId);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.scannerId = iprot.readI32();
+ struct.setScannerIdIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class closeScanner_result implements org.apache.thrift.TBase<closeScanner_result, closeScanner_result._Fields>, java.io.Serializable, Cloneable, Comparable<closeScanner_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new closeScanner_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new closeScanner_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+ /**
+ * if the scannerId is invalid
+ */
+ public @org.apache.thrift.annotation.Nullable TIllegalArgument ia; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io"),
+ /**
+ * if the scannerId is invalid
+ */
+ IA((short)2, "ia");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ case 2: // IA
+ return IA;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIllegalArgument.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_result.class, metaDataMap);
+ }
+
+ public closeScanner_result() {
+ }
+
+ public closeScanner_result(
+ TIOError io,
+ TIllegalArgument ia)
+ {
+ this();
+ this.io = io;
+ this.ia = ia;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public closeScanner_result(closeScanner_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ if (other.isSetIa()) {
+ this.ia = new TIllegalArgument(other.ia);
+ }
+ }
+
+ public closeScanner_result deepCopy() {
+ return new closeScanner_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ this.ia = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public closeScanner_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ /**
+ * if the scannerId is invalid
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TIllegalArgument getIa() {
+ return this.ia;
+ }
+
+ /**
+ * if the scannerId is invalid
+ */
+ public closeScanner_result setIa(@org.apache.thrift.annotation.Nullable TIllegalArgument ia) {
+ this.ia = ia;
+ return this;
+ }
+
+ public void unsetIa() {
+ this.ia = null;
+ }
+
+ /** Returns true if field ia is set (has been assigned a value) and false otherwise */
+ public boolean isSetIa() {
+ return this.ia != null;
+ }
+
+ public void setIaIsSet(boolean value) {
+ if (!value) {
+ this.ia = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ case IA:
+ if (value == null) {
+ unsetIa();
+ } else {
+ setIa((TIllegalArgument)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ case IA:
+ return getIa();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ case IA:
+ return isSetIa();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof closeScanner_result)
+ return this.equals((closeScanner_result)that);
+ return false;
+ }
+
+ public boolean equals(closeScanner_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ boolean this_present_ia = true && this.isSetIa();
+ boolean that_present_ia = true && that.isSetIa();
+ if (this_present_ia || that_present_ia) {
+ if (!(this_present_ia && that_present_ia))
+ return false;
+ if (!this.ia.equals(that.ia))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIa()) ? 131071 : 524287);
+ if (isSetIa())
+ hashCode = hashCode * 8191 + ia.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(closeScanner_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIa(), other.isSetIa());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIa()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, other.ia);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("closeScanner_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("ia:");
+ if (this.ia == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.ia);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class closeScanner_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public closeScanner_resultStandardScheme getScheme() {
+ return new closeScanner_resultStandardScheme();
+ }
+ }
+
+ private static class closeScanner_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<closeScanner_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // IA
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.ia = new TIllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.ia != null) {
+ oprot.writeFieldBegin(IA_FIELD_DESC);
+ struct.ia.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class closeScanner_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public closeScanner_resultTupleScheme getScheme() {
+ return new closeScanner_resultTupleScheme();
+ }
+ }
+
+ private static class closeScanner_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<closeScanner_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIa()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ if (struct.isSetIa()) {
+ struct.ia.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.ia = new TIllegalArgument();
+ struct.ia.read(iprot);
+ struct.setIaIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRow_args implements org.apache.thrift.TBase<mutateRow_args, mutateRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_args> {
+ 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_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TROW_MUTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("trowMutations", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRow_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRow_argsTupleSchemeFactory();
+
+ /**
+ * table to apply the mutations
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * mutations to apply
+ */
+ public @org.apache.thrift.annotation.Nullable TRowMutations trowMutations; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * table to apply the mutations
+ */
+ TABLE((short)1, "table"),
+ /**
+ * mutations to apply
+ */
+ TROW_MUTATIONS((short)2, "trowMutations");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TROW_MUTATIONS
+ return TROW_MUTATIONS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TROW_MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("trowMutations", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowMutations.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
+ }
+
+ public mutateRow_args() {
+ }
+
+ public mutateRow_args(
+ java.nio.ByteBuffer table,
+ TRowMutations trowMutations)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.trowMutations = trowMutations;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRow_args(mutateRow_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTrowMutations()) {
+ this.trowMutations = new TRowMutations(other.trowMutations);
+ }
+ }
+
+ public mutateRow_args deepCopy() {
+ return new mutateRow_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.trowMutations = null;
+ }
+
+ /**
+ * table to apply the mutations
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * table to apply the mutations
+ */
+ public mutateRow_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public mutateRow_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * mutations to apply
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TRowMutations getTrowMutations() {
+ return this.trowMutations;
+ }
+
+ /**
+ * mutations to apply
+ */
+ public mutateRow_args setTrowMutations(@org.apache.thrift.annotation.Nullable TRowMutations trowMutations) {
+ this.trowMutations = trowMutations;
+ return this;
+ }
+
+ public void unsetTrowMutations() {
+ this.trowMutations = null;
+ }
+
+ /** Returns true if field trowMutations is set (has been assigned a value) and false otherwise */
+ public boolean isSetTrowMutations() {
+ return this.trowMutations != null;
+ }
+
+ public void setTrowMutationsIsSet(boolean value) {
+ if (!value) {
+ this.trowMutations = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TROW_MUTATIONS:
+ if (value == null) {
+ unsetTrowMutations();
+ } else {
+ setTrowMutations((TRowMutations)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TROW_MUTATIONS:
+ return getTrowMutations();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TROW_MUTATIONS:
+ return isSetTrowMutations();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRow_args)
+ return this.equals((mutateRow_args)that);
+ return false;
+ }
+
+ public boolean equals(mutateRow_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_trowMutations = true && this.isSetTrowMutations();
+ boolean that_present_trowMutations = true && that.isSetTrowMutations();
+ if (this_present_trowMutations || that_present_trowMutations) {
+ if (!(this_present_trowMutations && that_present_trowMutations))
+ return false;
+ if (!this.trowMutations.equals(that.trowMutations))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTrowMutations()) ? 131071 : 524287);
+ if (isSetTrowMutations())
+ hashCode = hashCode * 8191 + trowMutations.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRow_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTrowMutations(), other.isSetTrowMutations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTrowMutations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.trowMutations, other.trowMutations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRow_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("trowMutations:");
+ if (this.trowMutations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.trowMutations);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (trowMutations == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'trowMutations' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (trowMutations != null) {
+ trowMutations.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRow_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_argsStandardScheme getScheme() {
+ return new mutateRow_argsStandardScheme();
+ }
+ }
+
+ private static class mutateRow_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRow_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TROW_MUTATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.trowMutations = new TRowMutations();
+ struct.trowMutations.read(iprot);
+ struct.setTrowMutationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.trowMutations != null) {
+ oprot.writeFieldBegin(TROW_MUTATIONS_FIELD_DESC);
+ struct.trowMutations.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRow_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_argsTupleScheme getScheme() {
+ return new mutateRow_argsTupleScheme();
+ }
+ }
+
+ private static class mutateRow_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRow_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.trowMutations.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.trowMutations = new TRowMutations();
+ struct.trowMutations.read(iprot);
+ struct.setTrowMutationsIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class mutateRow_result implements org.apache.thrift.TBase<mutateRow_result, mutateRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_result> {
+ 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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new mutateRow_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new mutateRow_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
+ }
+
+ public mutateRow_result() {
+ }
+
+ public mutateRow_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public mutateRow_result(mutateRow_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public mutateRow_result deepCopy() {
+ return new mutateRow_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public mutateRow_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof mutateRow_result)
+ return this.equals((mutateRow_result)that);
+ return false;
+ }
+
+ public boolean equals(mutateRow_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(mutateRow_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("mutateRow_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class mutateRow_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_resultStandardScheme getScheme() {
+ return new mutateRow_resultStandardScheme();
+ }
+ }
+
+ private static class mutateRow_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<mutateRow_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class mutateRow_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public mutateRow_resultTupleScheme getScheme() {
+ return new mutateRow_resultTupleScheme();
+ }
+ }
+
+ private static class mutateRow_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<mutateRow_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getScannerResults_args implements org.apache.thrift.TBase<getScannerResults_args, getScannerResults_args._Fields>, java.io.Serializable, Cloneable, Comparable<getScannerResults_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerResults_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TSCAN_FIELD_DESC = new org.apache.thrift.protocol.TField("tscan", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+ private static final org.apache.thrift.protocol.TField NUM_ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("numRows", org.apache.thrift.protocol.TType.I32, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getScannerResults_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getScannerResults_argsTupleSchemeFactory();
+
+ /**
+ * the table to get the Scanner for
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * the scan object to get a Scanner for
+ */
+ public @org.apache.thrift.annotation.Nullable TScan tscan; // required
+ /**
+ * number of rows to return
+ */
+ public int numRows; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the table to get the Scanner for
+ */
+ TABLE((short)1, "table"),
+ /**
+ * the scan object to get a Scanner for
+ */
+ TSCAN((short)2, "tscan"),
+ /**
+ * number of rows to return
+ */
+ NUM_ROWS((short)3, "numRows");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // TSCAN
+ return TSCAN;
+ case 3: // NUM_ROWS
+ return NUM_ROWS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __NUMROWS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.TSCAN, new org.apache.thrift.meta_data.FieldMetaData("tscan", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
+ tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerResults_args.class, metaDataMap);
+ }
+
+ public getScannerResults_args() {
+ this.numRows = 1;
+
+ }
+
+ public getScannerResults_args(
+ java.nio.ByteBuffer table,
+ TScan tscan,
+ int numRows)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.tscan = tscan;
+ this.numRows = numRows;
+ setNumRowsIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getScannerResults_args(getScannerResults_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetTscan()) {
+ this.tscan = new TScan(other.tscan);
+ }
+ this.numRows = other.numRows;
+ }
+
+ public getScannerResults_args deepCopy() {
+ return new getScannerResults_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.tscan = null;
+ this.numRows = 1;
+
+ }
+
+ /**
+ * the table to get the Scanner for
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * the table to get the Scanner for
+ */
+ public getScannerResults_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public getScannerResults_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * the scan object to get a Scanner for
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TScan getTscan() {
+ return this.tscan;
+ }
+
+ /**
+ * the scan object to get a Scanner for
+ */
+ public getScannerResults_args setTscan(@org.apache.thrift.annotation.Nullable TScan tscan) {
+ this.tscan = tscan;
+ return this;
+ }
+
+ public void unsetTscan() {
+ this.tscan = null;
+ }
+
+ /** Returns true if field tscan is set (has been assigned a value) and false otherwise */
+ public boolean isSetTscan() {
+ return this.tscan != null;
+ }
+
+ public void setTscanIsSet(boolean value) {
+ if (!value) {
+ this.tscan = null;
+ }
+ }
+
+ /**
+ * number of rows to return
+ */
+ public int getNumRows() {
+ return this.numRows;
+ }
+
+ /**
+ * number of rows to return
+ */
+ public getScannerResults_args setNumRows(int numRows) {
+ this.numRows = numRows;
+ setNumRowsIsSet(true);
+ return this;
+ }
+
+ public void unsetNumRows() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __NUMROWS_ISSET_ID);
+ }
+
+ /** Returns true if field numRows is set (has been assigned a value) and false otherwise */
+ public boolean isSetNumRows() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __NUMROWS_ISSET_ID);
+ }
+
+ public void setNumRowsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __NUMROWS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case TSCAN:
+ if (value == null) {
+ unsetTscan();
+ } else {
+ setTscan((TScan)value);
+ }
+ break;
+
+ case NUM_ROWS:
+ if (value == null) {
+ unsetNumRows();
+ } else {
+ setNumRows((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case TSCAN:
+ return getTscan();
+
+ case NUM_ROWS:
+ return getNumRows();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case TSCAN:
+ return isSetTscan();
+ case NUM_ROWS:
+ return isSetNumRows();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getScannerResults_args)
+ return this.equals((getScannerResults_args)that);
+ return false;
+ }
+
+ public boolean equals(getScannerResults_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_tscan = true && this.isSetTscan();
+ boolean that_present_tscan = true && that.isSetTscan();
+ if (this_present_tscan || that_present_tscan) {
+ if (!(this_present_tscan && that_present_tscan))
+ return false;
+ if (!this.tscan.equals(that.tscan))
+ return false;
+ }
+
+ boolean this_present_numRows = true;
+ boolean that_present_numRows = true;
+ if (this_present_numRows || that_present_numRows) {
+ if (!(this_present_numRows && that_present_numRows))
+ return false;
+ if (this.numRows != that.numRows)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTscan()) ? 131071 : 524287);
+ if (isSetTscan())
+ hashCode = hashCode * 8191 + tscan.hashCode();
+
+ hashCode = hashCode * 8191 + numRows;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getScannerResults_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTscan(), other.isSetTscan());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTscan()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tscan, other.tscan);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetNumRows(), other.isSetNumRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNumRows()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, other.numRows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getScannerResults_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tscan:");
+ if (this.tscan == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tscan);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("numRows:");
+ sb.append(this.numRows);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (tscan == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tscan' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tscan != null) {
+ tscan.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getScannerResults_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerResults_argsStandardScheme getScheme() {
+ return new getScannerResults_argsStandardScheme();
+ }
+ }
+
+ private static class getScannerResults_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getScannerResults_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerResults_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TSCAN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tscan = new TScan();
+ struct.tscan.read(iprot);
+ struct.setTscanIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // NUM_ROWS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.numRows = iprot.readI32();
+ struct.setNumRowsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerResults_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tscan != null) {
+ oprot.writeFieldBegin(TSCAN_FIELD_DESC);
+ struct.tscan.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
+ oprot.writeI32(struct.numRows);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getScannerResults_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerResults_argsTupleScheme getScheme() {
+ return new getScannerResults_argsTupleScheme();
+ }
+ }
+
+ private static class getScannerResults_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getScannerResults_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getScannerResults_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ struct.tscan.write(oprot);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetNumRows()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetNumRows()) {
+ oprot.writeI32(struct.numRows);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getScannerResults_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.tscan = new TScan();
+ struct.tscan.read(iprot);
+ struct.setTscanIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.numRows = iprot.readI32();
+ struct.setNumRowsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getScannerResults_result implements org.apache.thrift.TBase<getScannerResults_result, getScannerResults_result._Fields>, java.io.Serializable, Cloneable, Comparable<getScannerResults_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerResults_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getScannerResults_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getScannerResults_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TResult> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerResults_result.class, metaDataMap);
+ }
+
+ public getScannerResults_result() {
+ }
+
+ public getScannerResults_result(
+ java.util.List<TResult> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getScannerResults_result(getScannerResults_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TResult> __this__success = new java.util.ArrayList<TResult>(other.success.size());
+ for (TResult other_element : other.success) {
+ __this__success.add(new TResult(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getScannerResults_result deepCopy() {
+ return new getScannerResults_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TResult elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TResult>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TResult> getSuccess() {
+ return this.success;
+ }
+
+ public getScannerResults_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getScannerResults_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getScannerResults_result)
+ return this.equals((getScannerResults_result)that);
+ return false;
+ }
+
+ public boolean equals(getScannerResults_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getScannerResults_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getScannerResults_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getScannerResults_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerResults_resultStandardScheme getScheme() {
+ return new getScannerResults_resultStandardScheme();
+ }
+ }
+
+ private static class getScannerResults_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getScannerResults_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerResults_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list254 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TResult>(_list254.size);
+ @org.apache.thrift.annotation.Nullable TResult _elem255;
+ for (int _i256 = 0; _i256 < _list254.size; ++_i256)
+ {
+ _elem255 = new TResult();
+ _elem255.read(iprot);
+ struct.success.add(_elem255);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerResults_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TResult _iter257 : struct.success)
+ {
+ _iter257.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getScannerResults_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getScannerResults_resultTupleScheme getScheme() {
+ return new getScannerResults_resultTupleScheme();
+ }
+ }
+
+ private static class getScannerResults_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getScannerResults_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getScannerResults_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TResult _iter258 : struct.success)
+ {
+ _iter258.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getScannerResults_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list259 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TResult>(_list259.size);
+ @org.apache.thrift.annotation.Nullable TResult _elem260;
+ for (int _i261 = 0; _i261 < _list259.size; ++_i261)
+ {
+ _elem260 = new TResult();
+ _elem260.read(iprot);
+ struct.success.add(_elem260);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRegionLocation_args implements org.apache.thrift.TBase<getRegionLocation_args, getRegionLocation_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRegionLocation_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRegionLocation_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", 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 RELOAD_FIELD_DESC = new org.apache.thrift.protocol.TField("reload", org.apache.thrift.protocol.TType.BOOL, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRegionLocation_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRegionLocation_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public boolean reload; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ TABLE((short)1, "table"),
+ ROW((short)2, "row"),
+ RELOAD((short)3, "reload");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // ROW
+ return ROW;
+ case 3: // RELOAD
+ return RELOAD;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __RELOAD_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.RELOAD, new org.apache.thrift.meta_data.FieldMetaData("reload", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRegionLocation_args.class, metaDataMap);
+ }
+
+ public getRegionLocation_args() {
+ }
+
+ public getRegionLocation_args(
+ java.nio.ByteBuffer table,
+ java.nio.ByteBuffer row,
+ boolean reload)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.reload = reload;
+ setReloadIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRegionLocation_args(getRegionLocation_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ this.reload = other.reload;
+ }
+
+ public getRegionLocation_args deepCopy() {
+ return new getRegionLocation_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.row = null;
+ setReloadIsSet(false);
+ this.reload = false;
+ }
+
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ public getRegionLocation_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public getRegionLocation_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public getRegionLocation_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public getRegionLocation_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public boolean isReload() {
+ return this.reload;
+ }
+
+ public getRegionLocation_args setReload(boolean reload) {
+ this.reload = reload;
+ setReloadIsSet(true);
+ return this;
+ }
+
+ public void unsetReload() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __RELOAD_ISSET_ID);
+ }
+
+ /** Returns true if field reload is set (has been assigned a value) and false otherwise */
+ public boolean isSetReload() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __RELOAD_ISSET_ID);
+ }
+
+ public void setReloadIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __RELOAD_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case RELOAD:
+ if (value == null) {
+ unsetReload();
+ } else {
+ setReload((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case ROW:
+ return getRow();
+
+ case RELOAD:
+ return isReload();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case ROW:
+ return isSetRow();
+ case RELOAD:
+ return isSetReload();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRegionLocation_args)
+ return this.equals((getRegionLocation_args)that);
+ return false;
+ }
+
+ public boolean equals(getRegionLocation_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_reload = true;
+ boolean that_present_reload = true;
+ if (this_present_reload || that_present_reload) {
+ if (!(this_present_reload && that_present_reload))
+ return false;
+ if (this.reload != that.reload)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((reload) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRegionLocation_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetReload(), other.isSetReload());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReload()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.reload, other.reload);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRegionLocation_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("reload:");
+ sb.append(this.reload);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRegionLocation_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionLocation_argsStandardScheme getScheme() {
+ return new getRegionLocation_argsStandardScheme();
+ }
+ }
+
+ private static class getRegionLocation_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRegionLocation_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRegionLocation_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // RELOAD
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.reload = iprot.readBool();
+ struct.setReloadIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRegionLocation_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(RELOAD_FIELD_DESC);
+ oprot.writeBool(struct.reload);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRegionLocation_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionLocation_argsTupleScheme getScheme() {
+ return new getRegionLocation_argsTupleScheme();
+ }
+ }
+
+ private static class getRegionLocation_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRegionLocation_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRegionLocation_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ oprot.writeBinary(struct.row);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetReload()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetReload()) {
+ oprot.writeBool(struct.reload);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRegionLocation_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.reload = iprot.readBool();
+ struct.setReloadIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getRegionLocation_result implements org.apache.thrift.TBase<getRegionLocation_result, getRegionLocation_result._Fields>, java.io.Serializable, Cloneable, Comparable<getRegionLocation_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRegionLocation_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getRegionLocation_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getRegionLocation_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable THRegionLocation success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, THRegionLocation.class)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRegionLocation_result.class, metaDataMap);
+ }
+
+ public getRegionLocation_result() {
+ }
+
+ public getRegionLocation_result(
+ THRegionLocation success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRegionLocation_result(getRegionLocation_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new THRegionLocation(other.success);
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getRegionLocation_result deepCopy() {
+ return new getRegionLocation_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public THRegionLocation getSuccess() {
+ return this.success;
+ }
+
+ public getRegionLocation_result setSuccess(@org.apache.thrift.annotation.Nullable THRegionLocation success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getRegionLocation_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((THRegionLocation)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getRegionLocation_result)
+ return this.equals((getRegionLocation_result)that);
+ return false;
+ }
+
+ public boolean equals(getRegionLocation_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getRegionLocation_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getRegionLocation_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getRegionLocation_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionLocation_resultStandardScheme getScheme() {
+ return new getRegionLocation_resultStandardScheme();
+ }
+ }
+
+ private static class getRegionLocation_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getRegionLocation_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getRegionLocation_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new THRegionLocation();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getRegionLocation_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getRegionLocation_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getRegionLocation_resultTupleScheme getScheme() {
+ return new getRegionLocation_resultTupleScheme();
+ }
+ }
+
+ private static class getRegionLocation_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getRegionLocation_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getRegionLocation_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getRegionLocation_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = new THRegionLocation();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getAllRegionLocations_args implements org.apache.thrift.TBase<getAllRegionLocations_args, getAllRegionLocations_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAllRegionLocations_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllRegionLocations_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getAllRegionLocations_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getAllRegionLocations_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ TABLE((short)1, "table");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllRegionLocations_args.class, metaDataMap);
+ }
+
+ public getAllRegionLocations_args() {
+ }
+
+ public getAllRegionLocations_args(
+ java.nio.ByteBuffer table)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getAllRegionLocations_args(getAllRegionLocations_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ }
+
+ public getAllRegionLocations_args deepCopy() {
+ return new getAllRegionLocations_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ }
+
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ public getAllRegionLocations_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public getAllRegionLocations_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getAllRegionLocations_args)
+ return this.equals((getAllRegionLocations_args)that);
+ return false;
+ }
+
+ public boolean equals(getAllRegionLocations_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getAllRegionLocations_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getAllRegionLocations_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getAllRegionLocations_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getAllRegionLocations_argsStandardScheme getScheme() {
+ return new getAllRegionLocations_argsStandardScheme();
+ }
+ }
+
+ private static class getAllRegionLocations_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getAllRegionLocations_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getAllRegionLocations_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getAllRegionLocations_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getAllRegionLocations_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getAllRegionLocations_argsTupleScheme getScheme() {
+ return new getAllRegionLocations_argsTupleScheme();
+ }
+ }
+
+ private static class getAllRegionLocations_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getAllRegionLocations_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getAllRegionLocations_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getAllRegionLocations_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getAllRegionLocations_result implements org.apache.thrift.TBase<getAllRegionLocations_result, getAllRegionLocations_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAllRegionLocations_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllRegionLocations_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getAllRegionLocations_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getAllRegionLocations_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<THRegionLocation> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, THRegionLocation.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllRegionLocations_result.class, metaDataMap);
+ }
+
+ public getAllRegionLocations_result() {
+ }
+
+ public getAllRegionLocations_result(
+ java.util.List<THRegionLocation> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getAllRegionLocations_result(getAllRegionLocations_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<THRegionLocation> __this__success = new java.util.ArrayList<THRegionLocation>(other.success.size());
+ for (THRegionLocation other_element : other.success) {
+ __this__success.add(new THRegionLocation(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getAllRegionLocations_result deepCopy() {
+ return new getAllRegionLocations_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<THRegionLocation> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(THRegionLocation elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<THRegionLocation>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<THRegionLocation> getSuccess() {
+ return this.success;
+ }
+
+ public getAllRegionLocations_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<THRegionLocation> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getAllRegionLocations_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<THRegionLocation>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getAllRegionLocations_result)
+ return this.equals((getAllRegionLocations_result)that);
+ return false;
+ }
+
+ public boolean equals(getAllRegionLocations_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getAllRegionLocations_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getAllRegionLocations_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getAllRegionLocations_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getAllRegionLocations_resultStandardScheme getScheme() {
+ return new getAllRegionLocations_resultStandardScheme();
+ }
+ }
+
+ private static class getAllRegionLocations_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getAllRegionLocations_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getAllRegionLocations_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list262 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<THRegionLocation>(_list262.size);
+ @org.apache.thrift.annotation.Nullable THRegionLocation _elem263;
+ for (int _i264 = 0; _i264 < _list262.size; ++_i264)
+ {
+ _elem263 = new THRegionLocation();
+ _elem263.read(iprot);
+ struct.success.add(_elem263);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getAllRegionLocations_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (THRegionLocation _iter265 : struct.success)
+ {
+ _iter265.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getAllRegionLocations_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getAllRegionLocations_resultTupleScheme getScheme() {
+ return new getAllRegionLocations_resultTupleScheme();
+ }
+ }
+
+ private static class getAllRegionLocations_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getAllRegionLocations_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getAllRegionLocations_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (THRegionLocation _iter266 : struct.success)
+ {
+ _iter266.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getAllRegionLocations_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list267 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<THRegionLocation>(_list267.size);
+ @org.apache.thrift.annotation.Nullable THRegionLocation _elem268;
+ for (int _i269 = 0; _i269 < _list267.size; ++_i269)
+ {
+ _elem268 = new THRegionLocation();
+ _elem268.read(iprot);
+ struct.success.add(_elem268);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndMutate_args implements org.apache.thrift.TBase<checkAndMutate_args, checkAndMutate_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndMutate_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndMutate_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", 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 FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField COMPARE_OPERATOR_FIELD_DESC = new org.apache.thrift.protocol.TField("compareOperator", org.apache.thrift.protocol.TType.I32, (short)5);
+ private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)6);
+ private static final org.apache.thrift.protocol.TField ROW_MUTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("rowMutations", org.apache.thrift.protocol.TType.STRUCT, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndMutate_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndMutate_argsTupleSchemeFactory();
+
+ /**
+ * to check in and delete from
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table; // required
+ /**
+ * row to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ /**
+ * column family to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family; // required
+ /**
+ * column qualifier to check
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier; // required
+ /**
+ * comparison to make on the value
+ *
+ * @see TCompareOperator
+ */
+ public @org.apache.thrift.annotation.Nullable TCompareOperator compareOperator; // required
+ /**
+ * the expected value to be compared against, if not provided the
+ * check is for the non-existence of the column in question
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value; // required
+ /**
+ * row mutations to execute if the value matches
+ */
+ public @org.apache.thrift.annotation.Nullable TRowMutations rowMutations; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * to check in and delete from
+ */
+ TABLE((short)1, "table"),
+ /**
+ * row to check
+ */
+ ROW((short)2, "row"),
+ /**
+ * column family to check
+ */
+ FAMILY((short)3, "family"),
+ /**
+ * column qualifier to check
+ */
+ QUALIFIER((short)4, "qualifier"),
+ /**
+ * comparison to make on the value
+ *
+ * @see TCompareOperator
+ */
+ COMPARE_OPERATOR((short)5, "compareOperator"),
+ /**
+ * the expected value to be compared against, if not provided the
+ * check is for the non-existence of the column in question
+ */
+ VALUE((short)6, "value"),
+ /**
+ * row mutations to execute if the value matches
+ */
+ ROW_MUTATIONS((short)7, "rowMutations");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ case 2: // ROW
+ return ROW;
+ case 3: // FAMILY
+ return FAMILY;
+ case 4: // QUALIFIER
+ return QUALIFIER;
+ case 5: // COMPARE_OPERATOR
+ return COMPARE_OPERATOR;
+ case 6: // VALUE
+ return VALUE;
+ case 7: // ROW_MUTATIONS
+ return ROW_MUTATIONS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.COMPARE_OPERATOR, new org.apache.thrift.meta_data.FieldMetaData("compareOperator", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TCompareOperator.class)));
+ 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.STRING , true)));
+ tmpMap.put(_Fields.ROW_MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("rowMutations", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowMutations.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndMutate_args.class, metaDataMap);
+ }
+
+ public checkAndMutate_args() {
+ }
+
+ public checkAndMutate_args(
+ java.nio.ByteBuffer table,
+ java.nio.ByteBuffer row,
+ java.nio.ByteBuffer family,
+ java.nio.ByteBuffer qualifier,
+ TCompareOperator compareOperator,
+ java.nio.ByteBuffer value,
+ TRowMutations rowMutations)
+ {
+ this();
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ this.compareOperator = compareOperator;
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ this.rowMutations = rowMutations;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndMutate_args(checkAndMutate_args other) {
+ if (other.isSetTable()) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
+ }
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetFamily()) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
+ }
+ if (other.isSetQualifier()) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
+ }
+ if (other.isSetCompareOperator()) {
+ this.compareOperator = other.compareOperator;
+ }
+ if (other.isSetValue()) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
+ }
+ if (other.isSetRowMutations()) {
+ this.rowMutations = new TRowMutations(other.rowMutations);
+ }
+ }
+
+ public checkAndMutate_args deepCopy() {
+ return new checkAndMutate_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ this.row = null;
+ this.family = null;
+ this.qualifier = null;
+ this.compareOperator = null;
+ this.value = null;
+ this.rowMutations = null;
+ }
+
+ /**
+ * to check in and delete from
+ */
+ public byte[] getTable() {
+ setTable(org.apache.thrift.TBaseHelper.rightSize(table));
+ return table == null ? null : table.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTable() {
+ return org.apache.thrift.TBaseHelper.copyBinary(table);
+ }
+
+ /**
+ * to check in and delete from
+ */
+ public checkAndMutate_args setTable(byte[] table) {
+ this.table = table == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(table.clone());
+ return this;
+ }
+
+ public checkAndMutate_args setTable(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer table) {
+ this.table = org.apache.thrift.TBaseHelper.copyBinary(table);
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ /**
+ * row to check
+ */
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ /**
+ * row to check
+ */
+ public checkAndMutate_args setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public checkAndMutate_args setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ /**
+ * column family to check
+ */
+ public byte[] getFamily() {
+ setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
+ return family == null ? null : family.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFamily() {
+ return org.apache.thrift.TBaseHelper.copyBinary(family);
+ }
+
+ /**
+ * column family to check
+ */
+ public checkAndMutate_args setFamily(byte[] family) {
+ this.family = family == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(family.clone());
+ return this;
+ }
+
+ public checkAndMutate_args setFamily(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer family) {
+ this.family = org.apache.thrift.TBaseHelper.copyBinary(family);
+ return this;
+ }
+
+ public void unsetFamily() {
+ this.family = null;
+ }
+
+ /** Returns true if field family is set (has been assigned a value) and false otherwise */
+ public boolean isSetFamily() {
+ return this.family != null;
+ }
+
+ public void setFamilyIsSet(boolean value) {
+ if (!value) {
+ this.family = null;
+ }
+ }
+
+ /**
+ * column qualifier to check
+ */
+ public byte[] getQualifier() {
+ setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
+ return qualifier == null ? null : qualifier.array();
+ }
+
+ public java.nio.ByteBuffer bufferForQualifier() {
+ return org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ /**
+ * column qualifier to check
+ */
+ public checkAndMutate_args setQualifier(byte[] qualifier) {
+ this.qualifier = qualifier == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(qualifier.clone());
+ return this;
+ }
+
+ public checkAndMutate_args setQualifier(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ return this;
+ }
+
+ public void unsetQualifier() {
+ this.qualifier = null;
+ }
+
+ /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
+ public boolean isSetQualifier() {
+ return this.qualifier != null;
+ }
+
+ public void setQualifierIsSet(boolean value) {
+ if (!value) {
+ this.qualifier = null;
+ }
+ }
+
+ /**
+ * comparison to make on the value
+ *
+ * @see TCompareOperator
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TCompareOperator getCompareOperator() {
+ return this.compareOperator;
+ }
+
+ /**
+ * comparison to make on the value
+ *
+ * @see TCompareOperator
+ */
+ public checkAndMutate_args setCompareOperator(@org.apache.thrift.annotation.Nullable TCompareOperator compareOperator) {
+ this.compareOperator = compareOperator;
+ return this;
+ }
+
+ public void unsetCompareOperator() {
+ this.compareOperator = null;
+ }
+
+ /** Returns true if field compareOperator is set (has been assigned a value) and false otherwise */
+ public boolean isSetCompareOperator() {
+ return this.compareOperator != null;
+ }
+
+ public void setCompareOperatorIsSet(boolean value) {
+ if (!value) {
+ this.compareOperator = null;
+ }
+ }
+
+ /**
+ * the expected value to be compared against, if not provided the
+ * check is for the non-existence of the column in question
+ */
+ public byte[] getValue() {
+ setValue(org.apache.thrift.TBaseHelper.rightSize(value));
+ return value == null ? null : value.array();
+ }
+
+ public java.nio.ByteBuffer bufferForValue() {
+ return org.apache.thrift.TBaseHelper.copyBinary(value);
+ }
+
+ /**
+ * the expected value to be compared against, if not provided the
+ * check is for the non-existence of the column in question
+ */
+ public checkAndMutate_args setValue(byte[] value) {
+ this.value = value == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(value.clone());
+ return this;
+ }
+
+ public checkAndMutate_args setValue(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer value) {
+ this.value = org.apache.thrift.TBaseHelper.copyBinary(value);
+ return this;
+ }
+
+ public void unsetValue() {
+ this.value = null;
+ }
+
+ /** Returns true if field value is set (has been assigned a value) and false otherwise */
+ public boolean isSetValue() {
+ return this.value != null;
+ }
+
+ public void setValueIsSet(boolean value) {
+ if (!value) {
+ this.value = null;
+ }
+ }
+
+ /**
+ * row mutations to execute if the value matches
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TRowMutations getRowMutations() {
+ return this.rowMutations;
+ }
+
+ /**
+ * row mutations to execute if the value matches
+ */
+ public checkAndMutate_args setRowMutations(@org.apache.thrift.annotation.Nullable TRowMutations rowMutations) {
+ this.rowMutations = rowMutations;
+ return this;
+ }
+
+ public void unsetRowMutations() {
+ this.rowMutations = null;
+ }
+
+ /** Returns true if field rowMutations is set (has been assigned a value) and false otherwise */
+ public boolean isSetRowMutations() {
+ return this.rowMutations != null;
+ }
+
+ public void setRowMutationsIsSet(boolean value) {
+ if (!value) {
+ this.rowMutations = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ if (value instanceof byte[]) {
+ setTable((byte[])value);
+ } else {
+ setTable((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case FAMILY:
+ if (value == null) {
+ unsetFamily();
+ } else {
+ if (value instanceof byte[]) {
+ setFamily((byte[])value);
+ } else {
+ setFamily((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case QUALIFIER:
+ if (value == null) {
+ unsetQualifier();
+ } else {
+ if (value instanceof byte[]) {
+ setQualifier((byte[])value);
+ } else {
+ setQualifier((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COMPARE_OPERATOR:
+ if (value == null) {
+ unsetCompareOperator();
+ } else {
+ setCompareOperator((TCompareOperator)value);
+ }
+ break;
+
+ case VALUE:
+ if (value == null) {
+ unsetValue();
+ } else {
+ if (value instanceof byte[]) {
+ setValue((byte[])value);
+ } else {
+ setValue((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case ROW_MUTATIONS:
+ if (value == null) {
+ unsetRowMutations();
+ } else {
+ setRowMutations((TRowMutations)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ case ROW:
+ return getRow();
+
+ case FAMILY:
+ return getFamily();
+
+ case QUALIFIER:
+ return getQualifier();
+
+ case COMPARE_OPERATOR:
+ return getCompareOperator();
+
+ case VALUE:
+ return getValue();
+
+ case ROW_MUTATIONS:
+ return getRowMutations();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ case ROW:
+ return isSetRow();
+ case FAMILY:
+ return isSetFamily();
+ case QUALIFIER:
+ return isSetQualifier();
+ case COMPARE_OPERATOR:
+ return isSetCompareOperator();
+ case VALUE:
+ return isSetValue();
+ case ROW_MUTATIONS:
+ return isSetRowMutations();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndMutate_args)
+ return this.equals((checkAndMutate_args)that);
+ return false;
+ }
+
+ public boolean equals(checkAndMutate_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_family = true && this.isSetFamily();
+ boolean that_present_family = true && that.isSetFamily();
+ if (this_present_family || that_present_family) {
+ if (!(this_present_family && that_present_family))
+ return false;
+ if (!this.family.equals(that.family))
+ return false;
+ }
+
+ boolean this_present_qualifier = true && this.isSetQualifier();
+ boolean that_present_qualifier = true && that.isSetQualifier();
+ if (this_present_qualifier || that_present_qualifier) {
+ if (!(this_present_qualifier && that_present_qualifier))
+ return false;
+ if (!this.qualifier.equals(that.qualifier))
+ return false;
+ }
+
+ boolean this_present_compareOperator = true && this.isSetCompareOperator();
+ boolean that_present_compareOperator = true && that.isSetCompareOperator();
+ if (this_present_compareOperator || that_present_compareOperator) {
+ if (!(this_present_compareOperator && that_present_compareOperator))
+ return false;
+ if (!this.compareOperator.equals(that.compareOperator))
+ return false;
+ }
+
+ boolean this_present_value = true && this.isSetValue();
+ boolean that_present_value = true && that.isSetValue();
+ if (this_present_value || that_present_value) {
+ if (!(this_present_value && that_present_value))
+ return false;
+ if (!this.value.equals(that.value))
+ return false;
+ }
+
+ boolean this_present_rowMutations = true && this.isSetRowMutations();
+ boolean that_present_rowMutations = true && that.isSetRowMutations();
+ if (this_present_rowMutations || that_present_rowMutations) {
+ if (!(this_present_rowMutations && that_present_rowMutations))
+ return false;
+ if (!this.rowMutations.equals(that.rowMutations))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetFamily()) ? 131071 : 524287);
+ if (isSetFamily())
+ hashCode = hashCode * 8191 + family.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetQualifier()) ? 131071 : 524287);
+ if (isSetQualifier())
+ hashCode = hashCode * 8191 + qualifier.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetCompareOperator()) ? 131071 : 524287);
+ if (isSetCompareOperator())
+ hashCode = hashCode * 8191 + compareOperator.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetValue()) ? 131071 : 524287);
+ if (isSetValue())
+ hashCode = hashCode * 8191 + value.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRowMutations()) ? 131071 : 524287);
+ if (isSetRowMutations())
+ hashCode = hashCode * 8191 + rowMutations.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndMutate_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFamily(), other.isSetFamily());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFamily()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, other.family);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQualifier(), other.isSetQualifier());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQualifier()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, other.qualifier);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCompareOperator(), other.isSetCompareOperator());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCompareOperator()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.compareOperator, other.compareOperator);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetValue(), other.isSetValue());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValue()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRowMutations(), other.isSetRowMutations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRowMutations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowMutations, other.rowMutations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndMutate_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.table, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("family:");
+ if (this.family == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.family, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("qualifier:");
+ if (this.qualifier == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("compareOperator:");
+ if (this.compareOperator == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.compareOperator);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("value:");
+ if (this.value == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.value, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("rowMutations:");
+ if (this.rowMutations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.rowMutations);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ if (family == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
+ }
+ if (qualifier == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
+ }
+ if (compareOperator == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'compareOperator' was not present! Struct: " + toString());
+ }
+ if (rowMutations == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'rowMutations' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (rowMutations != null) {
+ rowMutations.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndMutate_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndMutate_argsStandardScheme getScheme() {
+ return new checkAndMutate_argsStandardScheme();
+ }
+ }
+
+ private static class checkAndMutate_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndMutate_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndMutate_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // FAMILY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // QUALIFIER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // COMPARE_OPERATOR
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.compareOperator = org.apache.hadoop.hbase.thrift2.generated.TCompareOperator.findByValue(iprot.readI32());
+ struct.setCompareOperatorIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // VALUE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // ROW_MUTATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.rowMutations = new TRowMutations();
+ struct.rowMutations.read(iprot);
+ struct.setRowMutationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndMutate_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ oprot.writeBinary(struct.table);
+ oprot.writeFieldEnd();
+ }
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.family != null) {
+ oprot.writeFieldBegin(FAMILY_FIELD_DESC);
+ oprot.writeBinary(struct.family);
+ oprot.writeFieldEnd();
+ }
+ if (struct.qualifier != null) {
+ oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeFieldEnd();
+ }
+ if (struct.compareOperator != null) {
+ oprot.writeFieldBegin(COMPARE_OPERATOR_FIELD_DESC);
+ oprot.writeI32(struct.compareOperator.getValue());
+ oprot.writeFieldEnd();
+ }
+ if (struct.value != null) {
+ oprot.writeFieldBegin(VALUE_FIELD_DESC);
+ oprot.writeBinary(struct.value);
+ oprot.writeFieldEnd();
+ }
+ if (struct.rowMutations != null) {
+ oprot.writeFieldBegin(ROW_MUTATIONS_FIELD_DESC);
+ struct.rowMutations.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndMutate_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndMutate_argsTupleScheme getScheme() {
+ return new checkAndMutate_argsTupleScheme();
+ }
+ }
+
+ private static class checkAndMutate_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndMutate_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndMutate_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.table);
+ oprot.writeBinary(struct.row);
+ oprot.writeBinary(struct.family);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeI32(struct.compareOperator.getValue());
+ struct.rowMutations.write(oprot);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetValue()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetValue()) {
+ oprot.writeBinary(struct.value);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndMutate_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = iprot.readBinary();
+ struct.setTableIsSet(true);
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ struct.family = iprot.readBinary();
+ struct.setFamilyIsSet(true);
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ struct.compareOperator = org.apache.hadoop.hbase.thrift2.generated.TCompareOperator.findByValue(iprot.readI32());
+ struct.setCompareOperatorIsSet(true);
+ struct.rowMutations = new TRowMutations();
+ struct.rowMutations.read(iprot);
+ struct.setRowMutationsIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.value = iprot.readBinary();
+ struct.setValueIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class checkAndMutate_result implements org.apache.thrift.TBase<checkAndMutate_result, checkAndMutate_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkAndMutate_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndMutate_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new checkAndMutate_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new checkAndMutate_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndMutate_result.class, metaDataMap);
+ }
+
+ public checkAndMutate_result() {
+ }
+
+ public checkAndMutate_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public checkAndMutate_result(checkAndMutate_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public checkAndMutate_result deepCopy() {
+ return new checkAndMutate_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public checkAndMutate_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public checkAndMutate_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof checkAndMutate_result)
+ return this.equals((checkAndMutate_result)that);
+ return false;
+ }
+
+ public boolean equals(checkAndMutate_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(checkAndMutate_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("checkAndMutate_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class checkAndMutate_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndMutate_resultStandardScheme getScheme() {
+ return new checkAndMutate_resultStandardScheme();
+ }
+ }
+
+ private static class checkAndMutate_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<checkAndMutate_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndMutate_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndMutate_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class checkAndMutate_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public checkAndMutate_resultTupleScheme getScheme() {
+ return new checkAndMutate_resultTupleScheme();
+ }
+ }
+
+ private static class checkAndMutate_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<checkAndMutate_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, checkAndMutate_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, checkAndMutate_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptor_args implements org.apache.thrift.TBase<getTableDescriptor_args, getTableDescriptor_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptor_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptor_args");
+
+ private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptor_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptor_argsTupleSchemeFactory();
+
+ /**
+ * the tablename of the table to get tableDescriptor
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName table; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename of the table to get tableDescriptor
+ */
+ TABLE((short)1, "table");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE
+ return TABLE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptor_args.class, metaDataMap);
+ }
+
+ public getTableDescriptor_args() {
+ }
+
+ public getTableDescriptor_args(
+ TTableName table)
+ {
+ this();
+ this.table = table;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptor_args(getTableDescriptor_args other) {
+ if (other.isSetTable()) {
+ this.table = new TTableName(other.table);
+ }
+ }
+
+ public getTableDescriptor_args deepCopy() {
+ return new getTableDescriptor_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.table = null;
+ }
+
+ /**
+ * the tablename of the table to get tableDescriptor
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTable() {
+ return this.table;
+ }
+
+ /**
+ * the tablename of the table to get tableDescriptor
+ */
+ public getTableDescriptor_args setTable(@org.apache.thrift.annotation.Nullable TTableName table) {
+ this.table = table;
+ return this;
+ }
+
+ public void unsetTable() {
+ this.table = null;
+ }
+
+ /** Returns true if field table is set (has been assigned a value) and false otherwise */
+ public boolean isSetTable() {
+ return this.table != null;
+ }
+
+ public void setTableIsSet(boolean value) {
+ if (!value) {
+ this.table = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE:
+ if (value == null) {
+ unsetTable();
+ } else {
+ setTable((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE:
+ return getTable();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE:
+ return isSetTable();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptor_args)
+ return this.equals((getTableDescriptor_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptor_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_table = true && this.isSetTable();
+ boolean that_present_table = true && that.isSetTable();
+ if (this_present_table || that_present_table) {
+ if (!(this_present_table && that_present_table))
+ return false;
+ if (!this.table.equals(that.table))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTable()) ? 131071 : 524287);
+ if (isSetTable())
+ hashCode = hashCode * 8191 + table.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptor_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTable(), other.isSetTable());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTable()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, other.table);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptor_args(");
+ boolean first = true;
+
+ sb.append("table:");
+ if (this.table == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.table);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (table == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (table != null) {
+ table.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptor_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptor_argsStandardScheme getScheme() {
+ return new getTableDescriptor_argsStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptor_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptor_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptor_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.table = new TTableName();
+ struct.table.read(iprot);
+ struct.setTableIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptor_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.table != null) {
+ oprot.writeFieldBegin(TABLE_FIELD_DESC);
+ struct.table.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptor_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptor_argsTupleScheme getScheme() {
+ return new getTableDescriptor_argsTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptor_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptor_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptor_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptor_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.table = new TTableName();
+ struct.table.read(iprot);
+ struct.setTableIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptor_result implements org.apache.thrift.TBase<getTableDescriptor_result, getTableDescriptor_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptor_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptor_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptor_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptor_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TTableDescriptor success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableDescriptor.class)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptor_result.class, metaDataMap);
+ }
+
+ public getTableDescriptor_result() {
+ }
+
+ public getTableDescriptor_result(
+ TTableDescriptor success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptor_result(getTableDescriptor_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TTableDescriptor(other.success);
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getTableDescriptor_result deepCopy() {
+ return new getTableDescriptor_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TTableDescriptor getSuccess() {
+ return this.success;
+ }
+
+ public getTableDescriptor_result setSuccess(@org.apache.thrift.annotation.Nullable TTableDescriptor success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getTableDescriptor_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TTableDescriptor)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptor_result)
+ return this.equals((getTableDescriptor_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptor_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptor_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptor_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptor_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptor_resultStandardScheme getScheme() {
+ return new getTableDescriptor_resultStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptor_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptor_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptor_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TTableDescriptor();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptor_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptor_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptor_resultTupleScheme getScheme() {
+ return new getTableDescriptor_resultTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptor_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptor_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptor_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptor_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = new TTableDescriptor();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptors_args implements org.apache.thrift.TBase<getTableDescriptors_args, getTableDescriptors_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptors_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptors_args");
+
+ private static final org.apache.thrift.protocol.TField TABLES_FIELD_DESC = new org.apache.thrift.protocol.TField("tables", org.apache.thrift.protocol.TType.LIST, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptors_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptors_argsTupleSchemeFactory();
+
+ /**
+ * the tablename list of the tables to get tableDescriptor
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<TTableName> tables; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename list of the tables to get tableDescriptor
+ */
+ TABLES((short)1, "tables");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLES
+ return TABLES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLES, new org.apache.thrift.meta_data.FieldMetaData("tables", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TTableName.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptors_args.class, metaDataMap);
+ }
+
+ public getTableDescriptors_args() {
+ }
+
+ public getTableDescriptors_args(
+ java.util.List<TTableName> tables)
+ {
+ this();
+ this.tables = tables;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptors_args(getTableDescriptors_args other) {
+ if (other.isSetTables()) {
+ java.util.List<TTableName> __this__tables = new java.util.ArrayList<TTableName>(other.tables.size());
+ for (TTableName other_element : other.tables) {
+ __this__tables.add(new TTableName(other_element));
+ }
+ this.tables = __this__tables;
+ }
+ }
+
+ public getTableDescriptors_args deepCopy() {
+ return new getTableDescriptors_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tables = null;
+ }
+
+ public int getTablesSize() {
+ return (this.tables == null) ? 0 : this.tables.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TTableName> getTablesIterator() {
+ return (this.tables == null) ? null : this.tables.iterator();
+ }
+
+ public void addToTables(TTableName elem) {
+ if (this.tables == null) {
+ this.tables = new java.util.ArrayList<TTableName>();
+ }
+ this.tables.add(elem);
+ }
+
+ /**
+ * the tablename list of the tables to get tableDescriptor
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TTableName> getTables() {
+ return this.tables;
+ }
+
+ /**
+ * the tablename list of the tables to get tableDescriptor
+ */
+ public getTableDescriptors_args setTables(@org.apache.thrift.annotation.Nullable java.util.List<TTableName> tables) {
+ this.tables = tables;
+ return this;
+ }
+
+ public void unsetTables() {
+ this.tables = null;
+ }
+
+ /** Returns true if field tables is set (has been assigned a value) and false otherwise */
+ public boolean isSetTables() {
+ return this.tables != null;
+ }
+
+ public void setTablesIsSet(boolean value) {
+ if (!value) {
+ this.tables = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLES:
+ if (value == null) {
+ unsetTables();
+ } else {
+ setTables((java.util.List<TTableName>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLES:
+ return getTables();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLES:
+ return isSetTables();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptors_args)
+ return this.equals((getTableDescriptors_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptors_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tables = true && this.isSetTables();
+ boolean that_present_tables = true && that.isSetTables();
+ if (this_present_tables || that_present_tables) {
+ if (!(this_present_tables && that_present_tables))
+ return false;
+ if (!this.tables.equals(that.tables))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTables()) ? 131071 : 524287);
+ if (isSetTables())
+ hashCode = hashCode * 8191 + tables.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptors_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTables(), other.isSetTables());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTables()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tables, other.tables);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptors_args(");
+ boolean first = true;
+
+ sb.append("tables:");
+ if (this.tables == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tables);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tables == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tables' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptors_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptors_argsStandardScheme getScheme() {
+ return new getTableDescriptors_argsStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptors_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptors_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list270 = iprot.readListBegin();
+ struct.tables = new java.util.ArrayList<TTableName>(_list270.size);
+ @org.apache.thrift.annotation.Nullable TTableName _elem271;
+ for (int _i272 = 0; _i272 < _list270.size; ++_i272)
+ {
+ _elem271 = new TTableName();
+ _elem271.read(iprot);
+ struct.tables.add(_elem271);
+ }
+ iprot.readListEnd();
+ }
+ struct.setTablesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptors_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tables != null) {
+ oprot.writeFieldBegin(TABLES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.tables.size()));
+ for (TTableName _iter273 : struct.tables)
+ {
+ _iter273.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptors_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptors_argsTupleScheme getScheme() {
+ return new getTableDescriptors_argsTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptors_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptors_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ {
+ oprot.writeI32(struct.tables.size());
+ for (TTableName _iter274 : struct.tables)
+ {
+ _iter274.write(oprot);
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ {
+ org.apache.thrift.protocol.TList _list275 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.tables = new java.util.ArrayList<TTableName>(_list275.size);
+ @org.apache.thrift.annotation.Nullable TTableName _elem276;
+ for (int _i277 = 0; _i277 < _list275.size; ++_i277)
+ {
+ _elem276 = new TTableName();
+ _elem276.read(iprot);
+ struct.tables.add(_elem276);
+ }
+ }
+ struct.setTablesIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptors_result implements org.apache.thrift.TBase<getTableDescriptors_result, getTableDescriptors_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptors_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptors_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptors_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptors_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TTableDescriptor> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableDescriptor.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptors_result.class, metaDataMap);
+ }
+
+ public getTableDescriptors_result() {
+ }
+
+ public getTableDescriptors_result(
+ java.util.List<TTableDescriptor> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptors_result(getTableDescriptors_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TTableDescriptor> __this__success = new java.util.ArrayList<TTableDescriptor>(other.success.size());
+ for (TTableDescriptor other_element : other.success) {
+ __this__success.add(new TTableDescriptor(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getTableDescriptors_result deepCopy() {
+ return new getTableDescriptors_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TTableDescriptor> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TTableDescriptor elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TTableDescriptor>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TTableDescriptor> getSuccess() {
+ return this.success;
+ }
+
+ public getTableDescriptors_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TTableDescriptor> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getTableDescriptors_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TTableDescriptor>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptors_result)
+ return this.equals((getTableDescriptors_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptors_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptors_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptors_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptors_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptors_resultStandardScheme getScheme() {
+ return new getTableDescriptors_resultStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptors_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptors_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list278 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TTableDescriptor>(_list278.size);
+ @org.apache.thrift.annotation.Nullable TTableDescriptor _elem279;
+ for (int _i280 = 0; _i280 < _list278.size; ++_i280)
+ {
+ _elem279 = new TTableDescriptor();
+ _elem279.read(iprot);
+ struct.success.add(_elem279);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptors_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TTableDescriptor _iter281 : struct.success)
+ {
+ _iter281.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptors_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptors_resultTupleScheme getScheme() {
+ return new getTableDescriptors_resultTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptors_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptors_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TTableDescriptor _iter282 : struct.success)
+ {
+ _iter282.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list283 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TTableDescriptor>(_list283.size);
+ @org.apache.thrift.annotation.Nullable TTableDescriptor _elem284;
+ for (int _i285 = 0; _i285 < _list283.size; ++_i285)
+ {
+ _elem284 = new TTableDescriptor();
+ _elem284.read(iprot);
+ struct.success.add(_elem284);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class tableExists_args implements org.apache.thrift.TBase<tableExists_args, tableExists_args._Fields>, java.io.Serializable, Cloneable, Comparable<tableExists_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("tableExists_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.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new tableExists_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new tableExists_argsTupleSchemeFactory();
+
+ /**
+ * the tablename of the tables to check
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename of the tables to check
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(tableExists_args.class, metaDataMap);
+ }
+
+ public tableExists_args() {
+ }
+
+ public tableExists_args(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public tableExists_args(tableExists_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ }
+
+ public tableExists_args deepCopy() {
+ return new tableExists_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * the tablename of the tables to check
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename of the tables to check
+ */
+ public tableExists_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof tableExists_args)
+ return this.equals((tableExists_args)that);
+ return false;
+ }
+
+ public boolean equals(tableExists_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(tableExists_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("tableExists_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class tableExists_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public tableExists_argsStandardScheme getScheme() {
+ return new tableExists_argsStandardScheme();
+ }
+ }
+
+ private static class tableExists_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<tableExists_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, tableExists_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, tableExists_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class tableExists_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public tableExists_argsTupleScheme getScheme() {
+ return new tableExists_argsTupleScheme();
+ }
+ }
+
+ private static class tableExists_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<tableExists_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, tableExists_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTableName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetTableName()) {
+ struct.tableName.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, tableExists_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class tableExists_result implements org.apache.thrift.TBase<tableExists_result, tableExists_result._Fields>, java.io.Serializable, Cloneable, Comparable<tableExists_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("tableExists_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new tableExists_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new tableExists_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(tableExists_result.class, metaDataMap);
+ }
+
+ public tableExists_result() {
+ }
+
+ public tableExists_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public tableExists_result(tableExists_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public tableExists_result deepCopy() {
+ return new tableExists_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public tableExists_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public tableExists_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof tableExists_result)
+ return this.equals((tableExists_result)that);
+ return false;
+ }
+
+ public boolean equals(tableExists_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(tableExists_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("tableExists_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class tableExists_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public tableExists_resultStandardScheme getScheme() {
+ return new tableExists_resultStandardScheme();
+ }
+ }
+
+ private static class tableExists_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<tableExists_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, tableExists_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, tableExists_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class tableExists_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public tableExists_resultTupleScheme getScheme() {
+ return new tableExists_resultTupleScheme();
+ }
+ }
+
+ private static class tableExists_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<tableExists_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, tableExists_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, tableExists_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptorsByPattern_args implements org.apache.thrift.TBase<getTableDescriptorsByPattern_args, getTableDescriptorsByPattern_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptorsByPattern_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptorsByPattern_args");
+
+ private static final org.apache.thrift.protocol.TField REGEX_FIELD_DESC = new org.apache.thrift.protocol.TField("regex", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField INCLUDE_SYS_TABLES_FIELD_DESC = new org.apache.thrift.protocol.TField("includeSysTables", org.apache.thrift.protocol.TType.BOOL, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptorsByPattern_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptorsByPattern_argsTupleSchemeFactory();
+
+ /**
+ * The regular expression to match against
+ */
+ public @org.apache.thrift.annotation.Nullable java.lang.String regex; // required
+ /**
+ * set to false if match only against userspace tables
+ */
+ public boolean includeSysTables; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * The regular expression to match against
+ */
+ REGEX((short)1, "regex"),
+ /**
+ * set to false if match only against userspace tables
+ */
+ INCLUDE_SYS_TABLES((short)2, "includeSysTables");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // REGEX
+ return REGEX;
+ case 2: // INCLUDE_SYS_TABLES
+ return INCLUDE_SYS_TABLES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __INCLUDESYSTABLES_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.REGEX, new org.apache.thrift.meta_data.FieldMetaData("regex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.INCLUDE_SYS_TABLES, new org.apache.thrift.meta_data.FieldMetaData("includeSysTables", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptorsByPattern_args.class, metaDataMap);
+ }
+
+ public getTableDescriptorsByPattern_args() {
+ }
+
+ public getTableDescriptorsByPattern_args(
+ java.lang.String regex,
+ boolean includeSysTables)
+ {
+ this();
+ this.regex = regex;
+ this.includeSysTables = includeSysTables;
+ setIncludeSysTablesIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptorsByPattern_args(getTableDescriptorsByPattern_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRegex()) {
+ this.regex = other.regex;
+ }
+ this.includeSysTables = other.includeSysTables;
+ }
+
+ public getTableDescriptorsByPattern_args deepCopy() {
+ return new getTableDescriptorsByPattern_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.regex = null;
+ setIncludeSysTablesIsSet(false);
+ this.includeSysTables = false;
+ }
+
+ /**
+ * The regular expression to match against
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getRegex() {
+ return this.regex;
+ }
+
+ /**
+ * The regular expression to match against
+ */
+ public getTableDescriptorsByPattern_args setRegex(@org.apache.thrift.annotation.Nullable java.lang.String regex) {
+ this.regex = regex;
+ return this;
+ }
+
+ public void unsetRegex() {
+ this.regex = null;
+ }
+
+ /** Returns true if field regex is set (has been assigned a value) and false otherwise */
+ public boolean isSetRegex() {
+ return this.regex != null;
+ }
+
+ public void setRegexIsSet(boolean value) {
+ if (!value) {
+ this.regex = null;
+ }
+ }
+
+ /**
+ * set to false if match only against userspace tables
+ */
+ public boolean isIncludeSysTables() {
+ return this.includeSysTables;
+ }
+
+ /**
+ * set to false if match only against userspace tables
+ */
+ public getTableDescriptorsByPattern_args setIncludeSysTables(boolean includeSysTables) {
+ this.includeSysTables = includeSysTables;
+ setIncludeSysTablesIsSet(true);
+ return this;
+ }
+
+ public void unsetIncludeSysTables() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __INCLUDESYSTABLES_ISSET_ID);
+ }
+
+ /** Returns true if field includeSysTables is set (has been assigned a value) and false otherwise */
+ public boolean isSetIncludeSysTables() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __INCLUDESYSTABLES_ISSET_ID);
+ }
+
+ public void setIncludeSysTablesIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __INCLUDESYSTABLES_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case REGEX:
+ if (value == null) {
+ unsetRegex();
+ } else {
+ setRegex((java.lang.String)value);
+ }
+ break;
+
+ case INCLUDE_SYS_TABLES:
+ if (value == null) {
+ unsetIncludeSysTables();
+ } else {
+ setIncludeSysTables((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REGEX:
+ return getRegex();
+
+ case INCLUDE_SYS_TABLES:
+ return isIncludeSysTables();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case REGEX:
+ return isSetRegex();
+ case INCLUDE_SYS_TABLES:
+ return isSetIncludeSysTables();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptorsByPattern_args)
+ return this.equals((getTableDescriptorsByPattern_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptorsByPattern_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_regex = true && this.isSetRegex();
+ boolean that_present_regex = true && that.isSetRegex();
+ if (this_present_regex || that_present_regex) {
+ if (!(this_present_regex && that_present_regex))
+ return false;
+ if (!this.regex.equals(that.regex))
+ return false;
+ }
+
+ boolean this_present_includeSysTables = true;
+ boolean that_present_includeSysTables = true;
+ if (this_present_includeSysTables || that_present_includeSysTables) {
+ if (!(this_present_includeSysTables && that_present_includeSysTables))
+ return false;
+ if (this.includeSysTables != that.includeSysTables)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRegex()) ? 131071 : 524287);
+ if (isSetRegex())
+ hashCode = hashCode * 8191 + regex.hashCode();
+
+ hashCode = hashCode * 8191 + ((includeSysTables) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptorsByPattern_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRegex(), other.isSetRegex());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRegex()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.regex, other.regex);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIncludeSysTables(), other.isSetIncludeSysTables());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIncludeSysTables()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.includeSysTables, other.includeSysTables);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptorsByPattern_args(");
+ boolean first = true;
+
+ sb.append("regex:");
+ if (this.regex == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.regex);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("includeSysTables:");
+ sb.append(this.includeSysTables);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // alas, we cannot check 'includeSysTables' because it's a primitive and you chose the non-beans generator.
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptorsByPattern_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByPattern_argsStandardScheme getScheme() {
+ return new getTableDescriptorsByPattern_argsStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByPattern_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptorsByPattern_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptorsByPattern_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // REGEX
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.regex = iprot.readString();
+ struct.setRegexIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // INCLUDE_SYS_TABLES
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.includeSysTables = iprot.readBool();
+ struct.setIncludeSysTablesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetIncludeSysTables()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'includeSysTables' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptorsByPattern_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.regex != null) {
+ oprot.writeFieldBegin(REGEX_FIELD_DESC);
+ oprot.writeString(struct.regex);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(INCLUDE_SYS_TABLES_FIELD_DESC);
+ oprot.writeBool(struct.includeSysTables);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptorsByPattern_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByPattern_argsTupleScheme getScheme() {
+ return new getTableDescriptorsByPattern_argsTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByPattern_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptorsByPattern_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByPattern_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBool(struct.includeSysTables);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRegex()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetRegex()) {
+ oprot.writeString(struct.regex);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByPattern_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.includeSysTables = iprot.readBool();
+ struct.setIncludeSysTablesIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.regex = iprot.readString();
+ struct.setRegexIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptorsByPattern_result implements org.apache.thrift.TBase<getTableDescriptorsByPattern_result, getTableDescriptorsByPattern_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptorsByPattern_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptorsByPattern_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptorsByPattern_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptorsByPattern_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TTableDescriptor> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableDescriptor.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptorsByPattern_result.class, metaDataMap);
+ }
+
+ public getTableDescriptorsByPattern_result() {
+ }
+
+ public getTableDescriptorsByPattern_result(
+ java.util.List<TTableDescriptor> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptorsByPattern_result(getTableDescriptorsByPattern_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TTableDescriptor> __this__success = new java.util.ArrayList<TTableDescriptor>(other.success.size());
+ for (TTableDescriptor other_element : other.success) {
+ __this__success.add(new TTableDescriptor(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getTableDescriptorsByPattern_result deepCopy() {
+ return new getTableDescriptorsByPattern_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TTableDescriptor> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TTableDescriptor elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TTableDescriptor>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TTableDescriptor> getSuccess() {
+ return this.success;
+ }
+
+ public getTableDescriptorsByPattern_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TTableDescriptor> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getTableDescriptorsByPattern_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TTableDescriptor>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptorsByPattern_result)
+ return this.equals((getTableDescriptorsByPattern_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptorsByPattern_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptorsByPattern_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptorsByPattern_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptorsByPattern_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByPattern_resultStandardScheme getScheme() {
+ return new getTableDescriptorsByPattern_resultStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByPattern_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptorsByPattern_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptorsByPattern_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list286 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TTableDescriptor>(_list286.size);
+ @org.apache.thrift.annotation.Nullable TTableDescriptor _elem287;
+ for (int _i288 = 0; _i288 < _list286.size; ++_i288)
+ {
+ _elem287 = new TTableDescriptor();
+ _elem287.read(iprot);
+ struct.success.add(_elem287);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptorsByPattern_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TTableDescriptor _iter289 : struct.success)
+ {
+ _iter289.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptorsByPattern_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByPattern_resultTupleScheme getScheme() {
+ return new getTableDescriptorsByPattern_resultTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByPattern_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptorsByPattern_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByPattern_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TTableDescriptor _iter290 : struct.success)
+ {
+ _iter290.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByPattern_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list291 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TTableDescriptor>(_list291.size);
+ @org.apache.thrift.annotation.Nullable TTableDescriptor _elem292;
+ for (int _i293 = 0; _i293 < _list291.size; ++_i293)
+ {
+ _elem292 = new TTableDescriptor();
+ _elem292.read(iprot);
+ struct.success.add(_elem292);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptorsByNamespace_args implements org.apache.thrift.TBase<getTableDescriptorsByNamespace_args, getTableDescriptorsByNamespace_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptorsByNamespace_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptorsByNamespace_args");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptorsByNamespace_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptorsByNamespace_argsTupleSchemeFactory();
+
+ /**
+ * The namesapce's name
+ */
+ public @org.apache.thrift.annotation.Nullable java.lang.String name; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * The namesapce's name
+ */
+ NAME((short)1, "name");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptorsByNamespace_args.class, metaDataMap);
+ }
+
+ public getTableDescriptorsByNamespace_args() {
+ }
+
+ public getTableDescriptorsByNamespace_args(
+ java.lang.String name)
+ {
+ this();
+ this.name = name;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptorsByNamespace_args(getTableDescriptorsByNamespace_args other) {
+ if (other.isSetName()) {
+ this.name = other.name;
+ }
+ }
+
+ public getTableDescriptorsByNamespace_args deepCopy() {
+ return new getTableDescriptorsByNamespace_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ }
+
+ /**
+ * The namesapce's name
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getName() {
+ return this.name;
+ }
+
+ /**
+ * The namesapce's name
+ */
+ public getTableDescriptorsByNamespace_args setName(@org.apache.thrift.annotation.Nullable java.lang.String name) {
+ this.name = name;
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ setName((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptorsByNamespace_args)
+ return this.equals((getTableDescriptorsByNamespace_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptorsByNamespace_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptorsByNamespace_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptorsByNamespace_args(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.name);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (name == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptorsByNamespace_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByNamespace_argsStandardScheme getScheme() {
+ return new getTableDescriptorsByNamespace_argsStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByNamespace_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptorsByNamespace_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptorsByNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptorsByNamespace_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeString(struct.name);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptorsByNamespace_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByNamespace_argsTupleScheme getScheme() {
+ return new getTableDescriptorsByNamespace_argsTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByNamespace_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptorsByNamespace_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.name);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableDescriptorsByNamespace_result implements org.apache.thrift.TBase<getTableDescriptorsByNamespace_result, getTableDescriptorsByNamespace_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableDescriptorsByNamespace_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableDescriptorsByNamespace_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableDescriptorsByNamespace_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableDescriptorsByNamespace_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TTableDescriptor> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableDescriptor.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableDescriptorsByNamespace_result.class, metaDataMap);
+ }
+
+ public getTableDescriptorsByNamespace_result() {
+ }
+
+ public getTableDescriptorsByNamespace_result(
+ java.util.List<TTableDescriptor> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableDescriptorsByNamespace_result(getTableDescriptorsByNamespace_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TTableDescriptor> __this__success = new java.util.ArrayList<TTableDescriptor>(other.success.size());
+ for (TTableDescriptor other_element : other.success) {
+ __this__success.add(new TTableDescriptor(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getTableDescriptorsByNamespace_result deepCopy() {
+ return new getTableDescriptorsByNamespace_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TTableDescriptor> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TTableDescriptor elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TTableDescriptor>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TTableDescriptor> getSuccess() {
+ return this.success;
+ }
+
+ public getTableDescriptorsByNamespace_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TTableDescriptor> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getTableDescriptorsByNamespace_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TTableDescriptor>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableDescriptorsByNamespace_result)
+ return this.equals((getTableDescriptorsByNamespace_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableDescriptorsByNamespace_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableDescriptorsByNamespace_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableDescriptorsByNamespace_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableDescriptorsByNamespace_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByNamespace_resultStandardScheme getScheme() {
+ return new getTableDescriptorsByNamespace_resultStandardScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByNamespace_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableDescriptorsByNamespace_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableDescriptorsByNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list294 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TTableDescriptor>(_list294.size);
+ @org.apache.thrift.annotation.Nullable TTableDescriptor _elem295;
+ for (int _i296 = 0; _i296 < _list294.size; ++_i296)
+ {
+ _elem295 = new TTableDescriptor();
+ _elem295.read(iprot);
+ struct.success.add(_elem295);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableDescriptorsByNamespace_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TTableDescriptor _iter297 : struct.success)
+ {
+ _iter297.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableDescriptorsByNamespace_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableDescriptorsByNamespace_resultTupleScheme getScheme() {
+ return new getTableDescriptorsByNamespace_resultTupleScheme();
+ }
+ }
+
+ private static class getTableDescriptorsByNamespace_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableDescriptorsByNamespace_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TTableDescriptor _iter298 : struct.success)
+ {
+ _iter298.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableDescriptorsByNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list299 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TTableDescriptor>(_list299.size);
+ @org.apache.thrift.annotation.Nullable TTableDescriptor _elem300;
+ for (int _i301 = 0; _i301 < _list299.size; ++_i301)
+ {
+ _elem300 = new TTableDescriptor();
+ _elem300.read(iprot);
+ struct.success.add(_elem300);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNamesByPattern_args implements org.apache.thrift.TBase<getTableNamesByPattern_args, getTableNamesByPattern_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNamesByPattern_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesByPattern_args");
+
+ private static final org.apache.thrift.protocol.TField REGEX_FIELD_DESC = new org.apache.thrift.protocol.TField("regex", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField INCLUDE_SYS_TABLES_FIELD_DESC = new org.apache.thrift.protocol.TField("includeSysTables", org.apache.thrift.protocol.TType.BOOL, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesByPattern_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesByPattern_argsTupleSchemeFactory();
+
+ /**
+ * The regular expression to match against
+ */
+ public @org.apache.thrift.annotation.Nullable java.lang.String regex; // required
+ /**
+ * set to false if match only against userspace tables
+ */
+ public boolean includeSysTables; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * The regular expression to match against
+ */
+ REGEX((short)1, "regex"),
+ /**
+ * set to false if match only against userspace tables
+ */
+ INCLUDE_SYS_TABLES((short)2, "includeSysTables");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // REGEX
+ return REGEX;
+ case 2: // INCLUDE_SYS_TABLES
+ return INCLUDE_SYS_TABLES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __INCLUDESYSTABLES_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.REGEX, new org.apache.thrift.meta_data.FieldMetaData("regex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.INCLUDE_SYS_TABLES, new org.apache.thrift.meta_data.FieldMetaData("includeSysTables", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesByPattern_args.class, metaDataMap);
+ }
+
+ public getTableNamesByPattern_args() {
+ }
+
+ public getTableNamesByPattern_args(
+ java.lang.String regex,
+ boolean includeSysTables)
+ {
+ this();
+ this.regex = regex;
+ this.includeSysTables = includeSysTables;
+ setIncludeSysTablesIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNamesByPattern_args(getTableNamesByPattern_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRegex()) {
+ this.regex = other.regex;
+ }
+ this.includeSysTables = other.includeSysTables;
+ }
+
+ public getTableNamesByPattern_args deepCopy() {
+ return new getTableNamesByPattern_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.regex = null;
+ setIncludeSysTablesIsSet(false);
+ this.includeSysTables = false;
+ }
+
+ /**
+ * The regular expression to match against
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getRegex() {
+ return this.regex;
+ }
+
+ /**
+ * The regular expression to match against
+ */
+ public getTableNamesByPattern_args setRegex(@org.apache.thrift.annotation.Nullable java.lang.String regex) {
+ this.regex = regex;
+ return this;
+ }
+
+ public void unsetRegex() {
+ this.regex = null;
+ }
+
+ /** Returns true if field regex is set (has been assigned a value) and false otherwise */
+ public boolean isSetRegex() {
+ return this.regex != null;
+ }
+
+ public void setRegexIsSet(boolean value) {
+ if (!value) {
+ this.regex = null;
+ }
+ }
+
+ /**
+ * set to false if match only against userspace tables
+ */
+ public boolean isIncludeSysTables() {
+ return this.includeSysTables;
+ }
+
+ /**
+ * set to false if match only against userspace tables
+ */
+ public getTableNamesByPattern_args setIncludeSysTables(boolean includeSysTables) {
+ this.includeSysTables = includeSysTables;
+ setIncludeSysTablesIsSet(true);
+ return this;
+ }
+
+ public void unsetIncludeSysTables() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __INCLUDESYSTABLES_ISSET_ID);
+ }
+
+ /** Returns true if field includeSysTables is set (has been assigned a value) and false otherwise */
+ public boolean isSetIncludeSysTables() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __INCLUDESYSTABLES_ISSET_ID);
+ }
+
+ public void setIncludeSysTablesIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __INCLUDESYSTABLES_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case REGEX:
+ if (value == null) {
+ unsetRegex();
+ } else {
+ setRegex((java.lang.String)value);
+ }
+ break;
+
+ case INCLUDE_SYS_TABLES:
+ if (value == null) {
+ unsetIncludeSysTables();
+ } else {
+ setIncludeSysTables((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REGEX:
+ return getRegex();
+
+ case INCLUDE_SYS_TABLES:
+ return isIncludeSysTables();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case REGEX:
+ return isSetRegex();
+ case INCLUDE_SYS_TABLES:
+ return isSetIncludeSysTables();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNamesByPattern_args)
+ return this.equals((getTableNamesByPattern_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableNamesByPattern_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_regex = true && this.isSetRegex();
+ boolean that_present_regex = true && that.isSetRegex();
+ if (this_present_regex || that_present_regex) {
+ if (!(this_present_regex && that_present_regex))
+ return false;
+ if (!this.regex.equals(that.regex))
+ return false;
+ }
+
+ boolean this_present_includeSysTables = true;
+ boolean that_present_includeSysTables = true;
+ if (this_present_includeSysTables || that_present_includeSysTables) {
+ if (!(this_present_includeSysTables && that_present_includeSysTables))
+ return false;
+ if (this.includeSysTables != that.includeSysTables)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRegex()) ? 131071 : 524287);
+ if (isSetRegex())
+ hashCode = hashCode * 8191 + regex.hashCode();
+
+ hashCode = hashCode * 8191 + ((includeSysTables) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNamesByPattern_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRegex(), other.isSetRegex());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRegex()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.regex, other.regex);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIncludeSysTables(), other.isSetIncludeSysTables());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIncludeSysTables()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.includeSysTables, other.includeSysTables);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesByPattern_args(");
+ boolean first = true;
+
+ sb.append("regex:");
+ if (this.regex == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.regex);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("includeSysTables:");
+ sb.append(this.includeSysTables);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // alas, we cannot check 'includeSysTables' because it's a primitive and you chose the non-beans generator.
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNamesByPattern_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByPattern_argsStandardScheme getScheme() {
+ return new getTableNamesByPattern_argsStandardScheme();
+ }
+ }
+
+ private static class getTableNamesByPattern_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNamesByPattern_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesByPattern_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // REGEX
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.regex = iprot.readString();
+ struct.setRegexIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // INCLUDE_SYS_TABLES
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.includeSysTables = iprot.readBool();
+ struct.setIncludeSysTablesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetIncludeSysTables()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'includeSysTables' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNamesByPattern_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.regex != null) {
+ oprot.writeFieldBegin(REGEX_FIELD_DESC);
+ oprot.writeString(struct.regex);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(INCLUDE_SYS_TABLES_FIELD_DESC);
+ oprot.writeBool(struct.includeSysTables);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNamesByPattern_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByPattern_argsTupleScheme getScheme() {
+ return new getTableNamesByPattern_argsTupleScheme();
+ }
+ }
+
+ private static class getTableNamesByPattern_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNamesByPattern_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesByPattern_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBool(struct.includeSysTables);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRegex()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetRegex()) {
+ oprot.writeString(struct.regex);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesByPattern_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.includeSysTables = iprot.readBool();
+ struct.setIncludeSysTablesIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.regex = iprot.readString();
+ struct.setRegexIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNamesByPattern_result implements org.apache.thrift.TBase<getTableNamesByPattern_result, getTableNamesByPattern_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNamesByPattern_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesByPattern_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesByPattern_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesByPattern_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TTableName> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesByPattern_result.class, metaDataMap);
+ }
+
+ public getTableNamesByPattern_result() {
+ }
+
+ public getTableNamesByPattern_result(
+ java.util.List<TTableName> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNamesByPattern_result(getTableNamesByPattern_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TTableName> __this__success = new java.util.ArrayList<TTableName>(other.success.size());
+ for (TTableName other_element : other.success) {
+ __this__success.add(new TTableName(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getTableNamesByPattern_result deepCopy() {
+ return new getTableNamesByPattern_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TTableName> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TTableName elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TTableName>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TTableName> getSuccess() {
+ return this.success;
+ }
+
+ public getTableNamesByPattern_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TTableName> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getTableNamesByPattern_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TTableName>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNamesByPattern_result)
+ return this.equals((getTableNamesByPattern_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableNamesByPattern_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNamesByPattern_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesByPattern_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNamesByPattern_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByPattern_resultStandardScheme getScheme() {
+ return new getTableNamesByPattern_resultStandardScheme();
+ }
+ }
+
+ private static class getTableNamesByPattern_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNamesByPattern_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesByPattern_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list302 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TTableName>(_list302.size);
+ @org.apache.thrift.annotation.Nullable TTableName _elem303;
+ for (int _i304 = 0; _i304 < _list302.size; ++_i304)
+ {
+ _elem303 = new TTableName();
+ _elem303.read(iprot);
+ struct.success.add(_elem303);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNamesByPattern_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TTableName _iter305 : struct.success)
+ {
+ _iter305.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNamesByPattern_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByPattern_resultTupleScheme getScheme() {
+ return new getTableNamesByPattern_resultTupleScheme();
+ }
+ }
+
+ private static class getTableNamesByPattern_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNamesByPattern_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesByPattern_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TTableName _iter306 : struct.success)
+ {
+ _iter306.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesByPattern_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list307 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TTableName>(_list307.size);
+ @org.apache.thrift.annotation.Nullable TTableName _elem308;
+ for (int _i309 = 0; _i309 < _list307.size; ++_i309)
+ {
+ _elem308 = new TTableName();
+ _elem308.read(iprot);
+ struct.success.add(_elem308);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNamesByNamespace_args implements org.apache.thrift.TBase<getTableNamesByNamespace_args, getTableNamesByNamespace_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNamesByNamespace_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesByNamespace_args");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesByNamespace_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesByNamespace_argsTupleSchemeFactory();
+
+ /**
+ * The namesapce's name
+ */
+ public @org.apache.thrift.annotation.Nullable java.lang.String name; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * The namesapce's name
+ */
+ NAME((short)1, "name");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesByNamespace_args.class, metaDataMap);
+ }
+
+ public getTableNamesByNamespace_args() {
+ }
+
+ public getTableNamesByNamespace_args(
+ java.lang.String name)
+ {
+ this();
+ this.name = name;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNamesByNamespace_args(getTableNamesByNamespace_args other) {
+ if (other.isSetName()) {
+ this.name = other.name;
+ }
+ }
+
+ public getTableNamesByNamespace_args deepCopy() {
+ return new getTableNamesByNamespace_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ }
+
+ /**
+ * The namesapce's name
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getName() {
+ return this.name;
+ }
+
+ /**
+ * The namesapce's name
+ */
+ public getTableNamesByNamespace_args setName(@org.apache.thrift.annotation.Nullable java.lang.String name) {
+ this.name = name;
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ setName((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNamesByNamespace_args)
+ return this.equals((getTableNamesByNamespace_args)that);
+ return false;
+ }
+
+ public boolean equals(getTableNamesByNamespace_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNamesByNamespace_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesByNamespace_args(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.name);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (name == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNamesByNamespace_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByNamespace_argsStandardScheme getScheme() {
+ return new getTableNamesByNamespace_argsStandardScheme();
+ }
+ }
+
+ private static class getTableNamesByNamespace_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNamesByNamespace_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesByNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNamesByNamespace_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeString(struct.name);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNamesByNamespace_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByNamespace_argsTupleScheme getScheme() {
+ return new getTableNamesByNamespace_argsTupleScheme();
+ }
+ }
+
+ private static class getTableNamesByNamespace_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNamesByNamespace_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesByNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.name);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesByNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getTableNamesByNamespace_result implements org.apache.thrift.TBase<getTableNamesByNamespace_result, getTableNamesByNamespace_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNamesByNamespace_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getTableNamesByNamespace_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getTableNamesByNamespace_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getTableNamesByNamespace_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TTableName> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getTableNamesByNamespace_result.class, metaDataMap);
+ }
+
+ public getTableNamesByNamespace_result() {
+ }
+
+ public getTableNamesByNamespace_result(
+ java.util.List<TTableName> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getTableNamesByNamespace_result(getTableNamesByNamespace_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TTableName> __this__success = new java.util.ArrayList<TTableName>(other.success.size());
+ for (TTableName other_element : other.success) {
+ __this__success.add(new TTableName(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getTableNamesByNamespace_result deepCopy() {
+ return new getTableNamesByNamespace_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TTableName> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TTableName elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TTableName>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TTableName> getSuccess() {
+ return this.success;
+ }
+
+ public getTableNamesByNamespace_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TTableName> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getTableNamesByNamespace_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TTableName>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getTableNamesByNamespace_result)
+ return this.equals((getTableNamesByNamespace_result)that);
+ return false;
+ }
+
+ public boolean equals(getTableNamesByNamespace_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getTableNamesByNamespace_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getTableNamesByNamespace_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getTableNamesByNamespace_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByNamespace_resultStandardScheme getScheme() {
+ return new getTableNamesByNamespace_resultStandardScheme();
+ }
+ }
+
+ private static class getTableNamesByNamespace_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getTableNamesByNamespace_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getTableNamesByNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list310 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TTableName>(_list310.size);
+ @org.apache.thrift.annotation.Nullable TTableName _elem311;
+ for (int _i312 = 0; _i312 < _list310.size; ++_i312)
+ {
+ _elem311 = new TTableName();
+ _elem311.read(iprot);
+ struct.success.add(_elem311);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getTableNamesByNamespace_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TTableName _iter313 : struct.success)
+ {
+ _iter313.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getTableNamesByNamespace_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getTableNamesByNamespace_resultTupleScheme getScheme() {
+ return new getTableNamesByNamespace_resultTupleScheme();
+ }
+ }
+
+ private static class getTableNamesByNamespace_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getTableNamesByNamespace_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getTableNamesByNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TTableName _iter314 : struct.success)
+ {
+ _iter314.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getTableNamesByNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list315 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TTableName>(_list315.size);
+ @org.apache.thrift.annotation.Nullable TTableName _elem316;
+ for (int _i317 = 0; _i317 < _list315.size; ++_i317)
+ {
+ _elem316 = new TTableName();
+ _elem316.read(iprot);
+ struct.success.add(_elem316);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class createTable_args implements org.apache.thrift.TBase<createTable_args, createTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_args> {
+ 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 DESC_FIELD_DESC = new org.apache.thrift.protocol.TField("desc", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField SPLIT_KEYS_FIELD_DESC = new org.apache.thrift.protocol.TField("splitKeys", org.apache.thrift.protocol.TType.LIST, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new createTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new createTable_argsTupleSchemeFactory();
+
+ /**
+ * table descriptor for table
+ */
+ public @org.apache.thrift.annotation.Nullable TTableDescriptor desc; // required
+ /**
+ * rray of split keys for the initial regions of the table
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> splitKeys; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * table descriptor for table
+ */
+ DESC((short)1, "desc"),
+ /**
+ * rray of split keys for the initial regions of the table
+ */
+ SPLIT_KEYS((short)2, "splitKeys");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // DESC
+ return DESC;
+ case 2: // SPLIT_KEYS
+ return SPLIT_KEYS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.DESC, new org.apache.thrift.meta_data.FieldMetaData("desc", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableDescriptor.class)));
+ tmpMap.put(_Fields.SPLIT_KEYS, new org.apache.thrift.meta_data.FieldMetaData("splitKeys", 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 , true))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap);
+ }
+
+ public createTable_args() {
+ }
+
+ public createTable_args(
+ TTableDescriptor desc,
+ java.util.List<java.nio.ByteBuffer> splitKeys)
+ {
+ this();
+ this.desc = desc;
+ this.splitKeys = splitKeys;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public createTable_args(createTable_args other) {
+ if (other.isSetDesc()) {
+ this.desc = new TTableDescriptor(other.desc);
+ }
+ if (other.isSetSplitKeys()) {
+ java.util.List<java.nio.ByteBuffer> __this__splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>(other.splitKeys);
+ this.splitKeys = __this__splitKeys;
+ }
+ }
+
+ public createTable_args deepCopy() {
+ return new createTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.desc = null;
+ this.splitKeys = null;
+ }
+
+ /**
+ * table descriptor for table
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableDescriptor getDesc() {
+ return this.desc;
+ }
+
+ /**
+ * table descriptor for table
+ */
+ public createTable_args setDesc(@org.apache.thrift.annotation.Nullable TTableDescriptor desc) {
+ this.desc = desc;
+ return this;
+ }
+
+ public void unsetDesc() {
+ this.desc = null;
+ }
+
+ /** Returns true if field desc is set (has been assigned a value) and false otherwise */
+ public boolean isSetDesc() {
+ return this.desc != null;
+ }
+
+ public void setDescIsSet(boolean value) {
+ if (!value) {
+ this.desc = null;
+ }
+ }
+
+ public int getSplitKeysSize() {
+ return (this.splitKeys == null) ? 0 : this.splitKeys.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getSplitKeysIterator() {
+ return (this.splitKeys == null) ? null : this.splitKeys.iterator();
+ }
+
+ public void addToSplitKeys(java.nio.ByteBuffer elem) {
+ if (this.splitKeys == null) {
+ this.splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.splitKeys.add(elem);
+ }
+
+ /**
+ * rray of split keys for the initial regions of the table
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getSplitKeys() {
+ return this.splitKeys;
+ }
+
+ /**
+ * rray of split keys for the initial regions of the table
+ */
+ public createTable_args setSplitKeys(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> splitKeys) {
+ this.splitKeys = splitKeys;
+ return this;
+ }
+
+ public void unsetSplitKeys() {
+ this.splitKeys = null;
+ }
+
+ /** Returns true if field splitKeys is set (has been assigned a value) and false otherwise */
+ public boolean isSetSplitKeys() {
+ return this.splitKeys != null;
+ }
+
+ public void setSplitKeysIsSet(boolean value) {
+ if (!value) {
+ this.splitKeys = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case DESC:
+ if (value == null) {
+ unsetDesc();
+ } else {
+ setDesc((TTableDescriptor)value);
+ }
+ break;
+
+ case SPLIT_KEYS:
+ if (value == null) {
+ unsetSplitKeys();
+ } else {
+ setSplitKeys((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case DESC:
+ return getDesc();
+
+ case SPLIT_KEYS:
+ return getSplitKeys();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case DESC:
+ return isSetDesc();
+ case SPLIT_KEYS:
+ return isSetSplitKeys();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof createTable_args)
+ return this.equals((createTable_args)that);
+ return false;
+ }
+
+ public boolean equals(createTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_desc = true && this.isSetDesc();
+ boolean that_present_desc = true && that.isSetDesc();
+ if (this_present_desc || that_present_desc) {
+ if (!(this_present_desc && that_present_desc))
+ return false;
+ if (!this.desc.equals(that.desc))
+ return false;
+ }
+
+ boolean this_present_splitKeys = true && this.isSetSplitKeys();
+ boolean that_present_splitKeys = true && that.isSetSplitKeys();
+ if (this_present_splitKeys || that_present_splitKeys) {
+ if (!(this_present_splitKeys && that_present_splitKeys))
+ return false;
+ if (!this.splitKeys.equals(that.splitKeys))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetDesc()) ? 131071 : 524287);
+ if (isSetDesc())
+ hashCode = hashCode * 8191 + desc.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetSplitKeys()) ? 131071 : 524287);
+ if (isSetSplitKeys())
+ hashCode = hashCode * 8191 + splitKeys.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(createTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetDesc(), other.isSetDesc());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDesc()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.desc, other.desc);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetSplitKeys(), other.isSetSplitKeys());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSplitKeys()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.splitKeys, other.splitKeys);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("createTable_args(");
+ boolean first = true;
+
+ sb.append("desc:");
+ if (this.desc == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.desc);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("splitKeys:");
+ if (this.splitKeys == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.splitKeys, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (desc == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'desc' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (desc != null) {
+ desc.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class createTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_argsStandardScheme getScheme() {
+ return new createTable_argsStandardScheme();
+ }
+ }
+
+ private static class createTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<createTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, createTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // DESC
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.desc = new TTableDescriptor();
+ struct.desc.read(iprot);
+ struct.setDescIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // SPLIT_KEYS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list318 = iprot.readListBegin();
+ struct.splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>(_list318.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem319;
+ for (int _i320 = 0; _i320 < _list318.size; ++_i320)
+ {
+ _elem319 = iprot.readBinary();
+ struct.splitKeys.add(_elem319);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSplitKeysIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, createTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.desc != null) {
+ oprot.writeFieldBegin(DESC_FIELD_DESC);
+ struct.desc.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.splitKeys != null) {
+ oprot.writeFieldBegin(SPLIT_KEYS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.splitKeys.size()));
+ for (java.nio.ByteBuffer _iter321 : struct.splitKeys)
+ {
+ oprot.writeBinary(_iter321);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class createTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_argsTupleScheme getScheme() {
+ return new createTable_argsTupleScheme();
+ }
+ }
+
+ private static class createTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<createTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, createTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.desc.write(oprot);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSplitKeys()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSplitKeys()) {
+ {
+ oprot.writeI32(struct.splitKeys.size());
+ for (java.nio.ByteBuffer _iter322 : struct.splitKeys)
+ {
+ oprot.writeBinary(_iter322);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, createTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.desc = new TTableDescriptor();
+ struct.desc.read(iprot);
+ struct.setDescIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list323 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>(_list323.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem324;
+ for (int _i325 = 0; _i325 < _list323.size; ++_i325)
+ {
+ _elem324 = iprot.readBinary();
+ struct.splitKeys.add(_elem324);
+ }
+ }
+ struct.setSplitKeysIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class createTable_result implements org.apache.thrift.TBase<createTable_result, createTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_result> {
+ 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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new createTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new createTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap);
+ }
+
+ public createTable_result() {
+ }
+
+ public createTable_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public createTable_result(createTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public createTable_result deepCopy() {
+ return new createTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public createTable_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof createTable_result)
+ return this.equals((createTable_result)that);
+ return false;
+ }
+
+ public boolean equals(createTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(createTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("createTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class createTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_resultStandardScheme getScheme() {
+ return new createTable_resultStandardScheme();
+ }
+ }
+
+ private static class createTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<createTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, createTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, createTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class createTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createTable_resultTupleScheme getScheme() {
+ return new createTable_resultTupleScheme();
+ }
+ }
+
+ private static class createTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<createTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, createTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, createTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteTable_args implements org.apache.thrift.TBase<deleteTable_args, deleteTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_args> {
+ 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.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteTable_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to delete
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to delete
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap);
+ }
+
+ public deleteTable_args() {
+ }
+
+ public deleteTable_args(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteTable_args(deleteTable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ }
+
+ public deleteTable_args deepCopy() {
+ return new deleteTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * the tablename to delete
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to delete
+ */
+ public deleteTable_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteTable_args)
+ return this.equals((deleteTable_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_argsStandardScheme getScheme() {
+ return new deleteTable_argsStandardScheme();
+ }
+ }
+
+ private static class deleteTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_argsTupleScheme getScheme() {
+ return new deleteTable_argsTupleScheme();
+ }
+ }
+
+ private static class deleteTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteTable_result implements org.apache.thrift.TBase<deleteTable_result, deleteTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap);
+ }
+
+ public deleteTable_result() {
+ }
+
+ public deleteTable_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteTable_result(deleteTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public deleteTable_result deepCopy() {
+ return new deleteTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public deleteTable_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteTable_result)
+ return this.equals((deleteTable_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_resultStandardScheme getScheme() {
+ return new deleteTable_resultStandardScheme();
+ }
+ }
+
+ private static class deleteTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteTable_resultTupleScheme getScheme() {
+ return new deleteTable_resultTupleScheme();
+ }
+ }
+
+ private static class deleteTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class truncateTable_args implements org.apache.thrift.TBase<truncateTable_args, truncateTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<truncateTable_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("truncateTable_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.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField PRESERVE_SPLITS_FIELD_DESC = new org.apache.thrift.protocol.TField("preserveSplits", org.apache.thrift.protocol.TType.BOOL, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new truncateTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new truncateTable_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to truncate
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+ /**
+ * whether to preserve previous splits
+ */
+ public boolean preserveSplits; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to truncate
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * whether to preserve previous splits
+ */
+ PRESERVE_SPLITS((short)2, "preserveSplits");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // PRESERVE_SPLITS
+ return PRESERVE_SPLITS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __PRESERVESPLITS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ tmpMap.put(_Fields.PRESERVE_SPLITS, new org.apache.thrift.meta_data.FieldMetaData("preserveSplits", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(truncateTable_args.class, metaDataMap);
+ }
+
+ public truncateTable_args() {
+ }
+
+ public truncateTable_args(
+ TTableName tableName,
+ boolean preserveSplits)
+ {
+ this();
+ this.tableName = tableName;
+ this.preserveSplits = preserveSplits;
+ setPreserveSplitsIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public truncateTable_args(truncateTable_args other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ this.preserveSplits = other.preserveSplits;
+ }
+
+ public truncateTable_args deepCopy() {
+ return new truncateTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ setPreserveSplitsIsSet(false);
+ this.preserveSplits = false;
+ }
+
+ /**
+ * the tablename to truncate
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to truncate
+ */
+ public truncateTable_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * whether to preserve previous splits
+ */
+ public boolean isPreserveSplits() {
+ return this.preserveSplits;
+ }
+
+ /**
+ * whether to preserve previous splits
+ */
+ public truncateTable_args setPreserveSplits(boolean preserveSplits) {
+ this.preserveSplits = preserveSplits;
+ setPreserveSplitsIsSet(true);
+ return this;
+ }
+
+ public void unsetPreserveSplits() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PRESERVESPLITS_ISSET_ID);
+ }
+
+ /** Returns true if field preserveSplits is set (has been assigned a value) and false otherwise */
+ public boolean isSetPreserveSplits() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PRESERVESPLITS_ISSET_ID);
+ }
+
+ public void setPreserveSplitsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PRESERVESPLITS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ case PRESERVE_SPLITS:
+ if (value == null) {
+ unsetPreserveSplits();
+ } else {
+ setPreserveSplits((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case PRESERVE_SPLITS:
+ return isPreserveSplits();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case PRESERVE_SPLITS:
+ return isSetPreserveSplits();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof truncateTable_args)
+ return this.equals((truncateTable_args)that);
+ return false;
+ }
+
+ public boolean equals(truncateTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_preserveSplits = true;
+ boolean that_present_preserveSplits = true;
+ if (this_present_preserveSplits || that_present_preserveSplits) {
+ if (!(this_present_preserveSplits && that_present_preserveSplits))
+ return false;
+ if (this.preserveSplits != that.preserveSplits)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((preserveSplits) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(truncateTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetPreserveSplits(), other.isSetPreserveSplits());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetPreserveSplits()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.preserveSplits, other.preserveSplits);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("truncateTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("preserveSplits:");
+ sb.append(this.preserveSplits);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // alas, we cannot check 'preserveSplits' because it's a primitive and you chose the non-beans generator.
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class truncateTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public truncateTable_argsStandardScheme getScheme() {
+ return new truncateTable_argsStandardScheme();
+ }
+ }
+
+ private static class truncateTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<truncateTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, truncateTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // PRESERVE_SPLITS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.preserveSplits = iprot.readBool();
+ struct.setPreserveSplitsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetPreserveSplits()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'preserveSplits' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, truncateTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(PRESERVE_SPLITS_FIELD_DESC);
+ oprot.writeBool(struct.preserveSplits);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class truncateTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public truncateTable_argsTupleScheme getScheme() {
+ return new truncateTable_argsTupleScheme();
+ }
+ }
+
+ private static class truncateTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<truncateTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, truncateTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ oprot.writeBool(struct.preserveSplits);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, truncateTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ struct.preserveSplits = iprot.readBool();
+ struct.setPreserveSplitsIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class truncateTable_result implements org.apache.thrift.TBase<truncateTable_result, truncateTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<truncateTable_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("truncateTable_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new truncateTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new truncateTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(truncateTable_result.class, metaDataMap);
+ }
+
+ public truncateTable_result() {
+ }
+
+ public truncateTable_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public truncateTable_result(truncateTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public truncateTable_result deepCopy() {
+ return new truncateTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public truncateTable_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof truncateTable_result)
+ return this.equals((truncateTable_result)that);
+ return false;
+ }
+
+ public boolean equals(truncateTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(truncateTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("truncateTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class truncateTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public truncateTable_resultStandardScheme getScheme() {
+ return new truncateTable_resultStandardScheme();
+ }
+ }
+
+ private static class truncateTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<truncateTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, truncateTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, truncateTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class truncateTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public truncateTable_resultTupleScheme getScheme() {
+ return new truncateTable_resultTupleScheme();
+ }
+ }
+
+ private static class truncateTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<truncateTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, truncateTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, truncateTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class enableTable_args implements org.apache.thrift.TBase<enableTable_args, enableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.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.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new enableTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new enableTable_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to enable
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to enable
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap);
+ }
+
+ public enableTable_args() {
+ }
+
+ public enableTable_args(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public enableTable_args(enableTable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ }
+
+ public enableTable_args deepCopy() {
+ return new enableTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * the tablename to enable
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to enable
+ */
+ public enableTable_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof enableTable_args)
+ return this.equals((enableTable_args)that);
+ return false;
+ }
+
+ public boolean equals(enableTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(enableTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("enableTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class enableTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_argsStandardScheme getScheme() {
+ return new enableTable_argsStandardScheme();
+ }
+ }
+
+ private static class enableTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<enableTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, enableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, enableTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class enableTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_argsTupleScheme getScheme() {
+ return new enableTable_argsTupleScheme();
+ }
+ }
+
+ private static class enableTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<enableTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, enableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, enableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class enableTable_result implements org.apache.thrift.TBase<enableTable_result, enableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new enableTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new enableTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap);
+ }
+
+ public enableTable_result() {
+ }
+
+ public enableTable_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public enableTable_result(enableTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public enableTable_result deepCopy() {
+ return new enableTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public enableTable_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof enableTable_result)
+ return this.equals((enableTable_result)that);
+ return false;
+ }
+
+ public boolean equals(enableTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(enableTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("enableTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class enableTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_resultStandardScheme getScheme() {
+ return new enableTable_resultStandardScheme();
+ }
+ }
+
+ private static class enableTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<enableTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, enableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, enableTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class enableTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public enableTable_resultTupleScheme getScheme() {
+ return new enableTable_resultTupleScheme();
+ }
+ }
+
+ private static class enableTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<enableTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, enableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, enableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class disableTable_args implements org.apache.thrift.TBase<disableTable_args, disableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_args> {
+ 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.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new disableTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new disableTable_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to disable
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to disable
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap);
+ }
+
+ public disableTable_args() {
+ }
+
+ public disableTable_args(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public disableTable_args(disableTable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ }
+
+ public disableTable_args deepCopy() {
+ return new disableTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * the tablename to disable
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to disable
+ */
+ public disableTable_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof disableTable_args)
+ return this.equals((disableTable_args)that);
+ return false;
+ }
+
+ public boolean equals(disableTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(disableTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("disableTable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class disableTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_argsStandardScheme getScheme() {
+ return new disableTable_argsStandardScheme();
+ }
+ }
+
+ private static class disableTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<disableTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, disableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, disableTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class disableTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_argsTupleScheme getScheme() {
+ return new disableTable_argsTupleScheme();
+ }
+ }
+
+ private static class disableTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<disableTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, disableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, disableTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class disableTable_result implements org.apache.thrift.TBase<disableTable_result, disableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new disableTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new disableTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap);
+ }
+
+ public disableTable_result() {
+ }
+
+ public disableTable_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public disableTable_result(disableTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public disableTable_result deepCopy() {
+ return new disableTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public disableTable_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof disableTable_result)
+ return this.equals((disableTable_result)that);
+ return false;
+ }
+
+ public boolean equals(disableTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(disableTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("disableTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class disableTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_resultStandardScheme getScheme() {
+ return new disableTable_resultStandardScheme();
+ }
+ }
+
+ private static class disableTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<disableTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, disableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, disableTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class disableTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public disableTable_resultTupleScheme getScheme() {
+ return new disableTable_resultTupleScheme();
+ }
+ }
+
+ private static class disableTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<disableTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, disableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, disableTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableEnabled_args implements org.apache.thrift.TBase<isTableEnabled_args, isTableEnabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_args> {
+ 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.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableEnabled_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableEnabled_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to check
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to check
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap);
+ }
+
+ public isTableEnabled_args() {
+ }
+
+ public isTableEnabled_args(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableEnabled_args(isTableEnabled_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ }
+
+ public isTableEnabled_args deepCopy() {
+ return new isTableEnabled_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * the tablename to check
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to check
+ */
+ public isTableEnabled_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableEnabled_args)
+ return this.equals((isTableEnabled_args)that);
+ return false;
+ }
+
+ public boolean equals(isTableEnabled_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableEnabled_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableEnabled_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableEnabled_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_argsStandardScheme getScheme() {
+ return new isTableEnabled_argsStandardScheme();
+ }
+ }
+
+ private static class isTableEnabled_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableEnabled_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableEnabled_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_argsTupleScheme getScheme() {
+ return new isTableEnabled_argsTupleScheme();
+ }
+ }
+
+ private static class isTableEnabled_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableEnabled_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableEnabled_result implements org.apache.thrift.TBase<isTableEnabled_result, isTableEnabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_result> {
+ 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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableEnabled_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableEnabled_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap);
+ }
+
+ public isTableEnabled_result() {
+ }
+
+ public isTableEnabled_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableEnabled_result(isTableEnabled_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public isTableEnabled_result deepCopy() {
+ return new isTableEnabled_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public isTableEnabled_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public isTableEnabled_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableEnabled_result)
+ return this.equals((isTableEnabled_result)that);
+ return false;
+ }
+
+ public boolean equals(isTableEnabled_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableEnabled_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableEnabled_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableEnabled_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_resultStandardScheme getScheme() {
+ return new isTableEnabled_resultStandardScheme();
+ }
+ }
+
+ private static class isTableEnabled_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableEnabled_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableEnabled_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableEnabled_resultTupleScheme getScheme() {
+ return new isTableEnabled_resultTupleScheme();
+ }
+ }
+
+ private static class isTableEnabled_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableEnabled_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableEnabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableDisabled_args implements org.apache.thrift.TBase<isTableDisabled_args, isTableDisabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableDisabled_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableDisabled_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.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableDisabled_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableDisabled_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to check
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to check
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableDisabled_args.class, metaDataMap);
+ }
+
+ public isTableDisabled_args() {
+ }
+
+ public isTableDisabled_args(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableDisabled_args(isTableDisabled_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ }
+
+ public isTableDisabled_args deepCopy() {
+ return new isTableDisabled_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * the tablename to check
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to check
+ */
+ public isTableDisabled_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableDisabled_args)
+ return this.equals((isTableDisabled_args)that);
+ return false;
+ }
+
+ public boolean equals(isTableDisabled_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableDisabled_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableDisabled_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableDisabled_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableDisabled_argsStandardScheme getScheme() {
+ return new isTableDisabled_argsStandardScheme();
+ }
+ }
+
+ private static class isTableDisabled_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableDisabled_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableDisabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableDisabled_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableDisabled_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableDisabled_argsTupleScheme getScheme() {
+ return new isTableDisabled_argsTupleScheme();
+ }
+ }
+
+ private static class isTableDisabled_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableDisabled_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableDisabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableDisabled_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableDisabled_result implements org.apache.thrift.TBase<isTableDisabled_result, isTableDisabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableDisabled_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableDisabled_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableDisabled_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableDisabled_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableDisabled_result.class, metaDataMap);
+ }
+
+ public isTableDisabled_result() {
+ }
+
+ public isTableDisabled_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableDisabled_result(isTableDisabled_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public isTableDisabled_result deepCopy() {
+ return new isTableDisabled_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public isTableDisabled_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public isTableDisabled_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableDisabled_result)
+ return this.equals((isTableDisabled_result)that);
+ return false;
+ }
+
+ public boolean equals(isTableDisabled_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableDisabled_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableDisabled_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableDisabled_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableDisabled_resultStandardScheme getScheme() {
+ return new isTableDisabled_resultStandardScheme();
+ }
+ }
+
+ private static class isTableDisabled_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableDisabled_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableDisabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableDisabled_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableDisabled_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableDisabled_resultTupleScheme getScheme() {
+ return new isTableDisabled_resultTupleScheme();
+ }
+ }
+
+ private static class isTableDisabled_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableDisabled_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableDisabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableDisabled_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableAvailable_args implements org.apache.thrift.TBase<isTableAvailable_args, isTableAvailable_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableAvailable_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableAvailable_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.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableAvailable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableAvailable_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to check
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to check
+ */
+ TABLE_NAME((short)1, "tableName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableAvailable_args.class, metaDataMap);
+ }
+
+ public isTableAvailable_args() {
+ }
+
+ public isTableAvailable_args(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableAvailable_args(isTableAvailable_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ }
+
+ public isTableAvailable_args deepCopy() {
+ return new isTableAvailable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ }
+
+ /**
+ * the tablename to check
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to check
+ */
+ public isTableAvailable_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableAvailable_args)
+ return this.equals((isTableAvailable_args)that);
+ return false;
+ }
+
+ public boolean equals(isTableAvailable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableAvailable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableAvailable_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableAvailable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailable_argsStandardScheme getScheme() {
+ return new isTableAvailable_argsStandardScheme();
+ }
+ }
+
+ private static class isTableAvailable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableAvailable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableAvailable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableAvailable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableAvailable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailable_argsTupleScheme getScheme() {
+ return new isTableAvailable_argsTupleScheme();
+ }
+ }
+
+ private static class isTableAvailable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableAvailable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableAvailable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableAvailable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableAvailable_result implements org.apache.thrift.TBase<isTableAvailable_result, isTableAvailable_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableAvailable_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableAvailable_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableAvailable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableAvailable_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableAvailable_result.class, metaDataMap);
+ }
+
+ public isTableAvailable_result() {
+ }
+
+ public isTableAvailable_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableAvailable_result(isTableAvailable_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public isTableAvailable_result deepCopy() {
+ return new isTableAvailable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public isTableAvailable_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public isTableAvailable_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableAvailable_result)
+ return this.equals((isTableAvailable_result)that);
+ return false;
+ }
+
+ public boolean equals(isTableAvailable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableAvailable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableAvailable_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableAvailable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailable_resultStandardScheme getScheme() {
+ return new isTableAvailable_resultStandardScheme();
+ }
+ }
+
+ private static class isTableAvailable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableAvailable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableAvailable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableAvailable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableAvailable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailable_resultTupleScheme getScheme() {
+ return new isTableAvailable_resultTupleScheme();
+ }
+ }
+
+ private static class isTableAvailable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableAvailable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableAvailable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableAvailable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableAvailableWithSplit_args implements org.apache.thrift.TBase<isTableAvailableWithSplit_args, isTableAvailableWithSplit_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableAvailableWithSplit_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableAvailableWithSplit_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.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField SPLIT_KEYS_FIELD_DESC = new org.apache.thrift.protocol.TField("splitKeys", org.apache.thrift.protocol.TType.LIST, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableAvailableWithSplit_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableAvailableWithSplit_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to check
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+ /**
+ * keys to check if the table has been created with all split keys
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> splitKeys; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to check
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * keys to check if the table has been created with all split keys
+ */
+ SPLIT_KEYS((short)2, "splitKeys");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // SPLIT_KEYS
+ return SPLIT_KEYS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ tmpMap.put(_Fields.SPLIT_KEYS, new org.apache.thrift.meta_data.FieldMetaData("splitKeys", 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 , true))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableAvailableWithSplit_args.class, metaDataMap);
+ }
+
+ public isTableAvailableWithSplit_args() {
+ }
+
+ public isTableAvailableWithSplit_args(
+ TTableName tableName,
+ java.util.List<java.nio.ByteBuffer> splitKeys)
+ {
+ this();
+ this.tableName = tableName;
+ this.splitKeys = splitKeys;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableAvailableWithSplit_args(isTableAvailableWithSplit_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ if (other.isSetSplitKeys()) {
+ java.util.List<java.nio.ByteBuffer> __this__splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>(other.splitKeys);
+ this.splitKeys = __this__splitKeys;
+ }
+ }
+
+ public isTableAvailableWithSplit_args deepCopy() {
+ return new isTableAvailableWithSplit_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.splitKeys = null;
+ }
+
+ /**
+ * the tablename to check
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to check
+ */
+ public isTableAvailableWithSplit_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getSplitKeysSize() {
+ return (this.splitKeys == null) ? 0 : this.splitKeys.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.nio.ByteBuffer> getSplitKeysIterator() {
+ return (this.splitKeys == null) ? null : this.splitKeys.iterator();
+ }
+
+ public void addToSplitKeys(java.nio.ByteBuffer elem) {
+ if (this.splitKeys == null) {
+ this.splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>();
+ }
+ this.splitKeys.add(elem);
+ }
+
+ /**
+ * keys to check if the table has been created with all split keys
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.nio.ByteBuffer> getSplitKeys() {
+ return this.splitKeys;
+ }
+
+ /**
+ * keys to check if the table has been created with all split keys
+ */
+ public isTableAvailableWithSplit_args setSplitKeys(@org.apache.thrift.annotation.Nullable java.util.List<java.nio.ByteBuffer> splitKeys) {
+ this.splitKeys = splitKeys;
+ return this;
+ }
+
+ public void unsetSplitKeys() {
+ this.splitKeys = null;
+ }
+
+ /** Returns true if field splitKeys is set (has been assigned a value) and false otherwise */
+ public boolean isSetSplitKeys() {
+ return this.splitKeys != null;
+ }
+
+ public void setSplitKeysIsSet(boolean value) {
+ if (!value) {
+ this.splitKeys = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ case SPLIT_KEYS:
+ if (value == null) {
+ unsetSplitKeys();
+ } else {
+ setSplitKeys((java.util.List<java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case SPLIT_KEYS:
+ return getSplitKeys();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case SPLIT_KEYS:
+ return isSetSplitKeys();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableAvailableWithSplit_args)
+ return this.equals((isTableAvailableWithSplit_args)that);
+ return false;
+ }
+
+ public boolean equals(isTableAvailableWithSplit_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_splitKeys = true && this.isSetSplitKeys();
+ boolean that_present_splitKeys = true && that.isSetSplitKeys();
+ if (this_present_splitKeys || that_present_splitKeys) {
+ if (!(this_present_splitKeys && that_present_splitKeys))
+ return false;
+ if (!this.splitKeys.equals(that.splitKeys))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetSplitKeys()) ? 131071 : 524287);
+ if (isSetSplitKeys())
+ hashCode = hashCode * 8191 + splitKeys.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableAvailableWithSplit_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetSplitKeys(), other.isSetSplitKeys());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSplitKeys()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.splitKeys, other.splitKeys);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableAvailableWithSplit_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("splitKeys:");
+ if (this.splitKeys == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.splitKeys, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableAvailableWithSplit_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailableWithSplit_argsStandardScheme getScheme() {
+ return new isTableAvailableWithSplit_argsStandardScheme();
+ }
+ }
+
+ private static class isTableAvailableWithSplit_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableAvailableWithSplit_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableAvailableWithSplit_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // SPLIT_KEYS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list326 = iprot.readListBegin();
+ struct.splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>(_list326.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem327;
+ for (int _i328 = 0; _i328 < _list326.size; ++_i328)
+ {
+ _elem327 = iprot.readBinary();
+ struct.splitKeys.add(_elem327);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSplitKeysIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableAvailableWithSplit_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.splitKeys != null) {
+ oprot.writeFieldBegin(SPLIT_KEYS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.splitKeys.size()));
+ for (java.nio.ByteBuffer _iter329 : struct.splitKeys)
+ {
+ oprot.writeBinary(_iter329);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableAvailableWithSplit_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailableWithSplit_argsTupleScheme getScheme() {
+ return new isTableAvailableWithSplit_argsTupleScheme();
+ }
+ }
+
+ private static class isTableAvailableWithSplit_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableAvailableWithSplit_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableAvailableWithSplit_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSplitKeys()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSplitKeys()) {
+ {
+ oprot.writeI32(struct.splitKeys.size());
+ for (java.nio.ByteBuffer _iter330 : struct.splitKeys)
+ {
+ oprot.writeBinary(_iter330);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableAvailableWithSplit_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list331 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.splitKeys = new java.util.ArrayList<java.nio.ByteBuffer>(_list331.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _elem332;
+ for (int _i333 = 0; _i333 < _list331.size; ++_i333)
+ {
+ _elem332 = iprot.readBinary();
+ struct.splitKeys.add(_elem332);
+ }
+ }
+ struct.setSplitKeysIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class isTableAvailableWithSplit_result implements org.apache.thrift.TBase<isTableAvailableWithSplit_result, isTableAvailableWithSplit_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableAvailableWithSplit_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTableAvailableWithSplit_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new isTableAvailableWithSplit_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new isTableAvailableWithSplit_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTableAvailableWithSplit_result.class, metaDataMap);
+ }
+
+ public isTableAvailableWithSplit_result() {
+ }
+
+ public isTableAvailableWithSplit_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public isTableAvailableWithSplit_result(isTableAvailableWithSplit_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public isTableAvailableWithSplit_result deepCopy() {
+ return new isTableAvailableWithSplit_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public isTableAvailableWithSplit_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public isTableAvailableWithSplit_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof isTableAvailableWithSplit_result)
+ return this.equals((isTableAvailableWithSplit_result)that);
+ return false;
+ }
+
+ public boolean equals(isTableAvailableWithSplit_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(isTableAvailableWithSplit_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("isTableAvailableWithSplit_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class isTableAvailableWithSplit_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailableWithSplit_resultStandardScheme getScheme() {
+ return new isTableAvailableWithSplit_resultStandardScheme();
+ }
+ }
+
+ private static class isTableAvailableWithSplit_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<isTableAvailableWithSplit_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, isTableAvailableWithSplit_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, isTableAvailableWithSplit_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class isTableAvailableWithSplit_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public isTableAvailableWithSplit_resultTupleScheme getScheme() {
+ return new isTableAvailableWithSplit_resultTupleScheme();
+ }
+ }
+
+ private static class isTableAvailableWithSplit_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<isTableAvailableWithSplit_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, isTableAvailableWithSplit_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, isTableAvailableWithSplit_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class addColumnFamily_args implements org.apache.thrift.TBase<addColumnFamily_args, addColumnFamily_args._Fields>, java.io.Serializable, Cloneable, Comparable<addColumnFamily_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addColumnFamily_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.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new addColumnFamily_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new addColumnFamily_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to add column family to
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+ /**
+ * column family descriptor of column family to be added
+ */
+ public @org.apache.thrift.annotation.Nullable TColumnFamilyDescriptor column; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to add column family to
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * column family descriptor of column family to be added
+ */
+ COLUMN((short)2, "column");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // COLUMN
+ return COLUMN;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumnFamilyDescriptor.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addColumnFamily_args.class, metaDataMap);
+ }
+
+ public addColumnFamily_args() {
+ }
+
+ public addColumnFamily_args(
+ TTableName tableName,
+ TColumnFamilyDescriptor column)
+ {
+ this();
+ this.tableName = tableName;
+ this.column = column;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public addColumnFamily_args(addColumnFamily_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ if (other.isSetColumn()) {
+ this.column = new TColumnFamilyDescriptor(other.column);
+ }
+ }
+
+ public addColumnFamily_args deepCopy() {
+ return new addColumnFamily_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.column = null;
+ }
+
+ /**
+ * the tablename to add column family to
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to add column family to
+ */
+ public addColumnFamily_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * column family descriptor of column family to be added
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TColumnFamilyDescriptor getColumn() {
+ return this.column;
+ }
+
+ /**
+ * column family descriptor of column family to be added
+ */
+ public addColumnFamily_args setColumn(@org.apache.thrift.annotation.Nullable TColumnFamilyDescriptor column) {
+ this.column = column;
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ setColumn((TColumnFamilyDescriptor)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case COLUMN:
+ return getColumn();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case COLUMN:
+ return isSetColumn();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof addColumnFamily_args)
+ return this.equals((addColumnFamily_args)that);
+ return false;
+ }
+
+ public boolean equals(addColumnFamily_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(addColumnFamily_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("addColumnFamily_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.column);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ if (column == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'column' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ if (column != null) {
+ column.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class addColumnFamily_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public addColumnFamily_argsStandardScheme getScheme() {
+ return new addColumnFamily_argsStandardScheme();
+ }
+ }
+
+ private static class addColumnFamily_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<addColumnFamily_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, addColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.column = new TColumnFamilyDescriptor();
+ struct.column.read(iprot);
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, addColumnFamily_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ struct.column.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class addColumnFamily_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public addColumnFamily_argsTupleScheme getScheme() {
+ return new addColumnFamily_argsTupleScheme();
+ }
+ }
+
+ private static class addColumnFamily_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<addColumnFamily_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, addColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ struct.column.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, addColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ struct.column = new TColumnFamilyDescriptor();
+ struct.column.read(iprot);
+ struct.setColumnIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class addColumnFamily_result implements org.apache.thrift.TBase<addColumnFamily_result, addColumnFamily_result._Fields>, java.io.Serializable, Cloneable, Comparable<addColumnFamily_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addColumnFamily_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new addColumnFamily_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new addColumnFamily_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addColumnFamily_result.class, metaDataMap);
+ }
+
+ public addColumnFamily_result() {
+ }
+
+ public addColumnFamily_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public addColumnFamily_result(addColumnFamily_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public addColumnFamily_result deepCopy() {
+ return new addColumnFamily_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public addColumnFamily_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof addColumnFamily_result)
+ return this.equals((addColumnFamily_result)that);
+ return false;
+ }
+
+ public boolean equals(addColumnFamily_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(addColumnFamily_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("addColumnFamily_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class addColumnFamily_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public addColumnFamily_resultStandardScheme getScheme() {
+ return new addColumnFamily_resultStandardScheme();
+ }
+ }
+
+ private static class addColumnFamily_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<addColumnFamily_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, addColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, addColumnFamily_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class addColumnFamily_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public addColumnFamily_resultTupleScheme getScheme() {
+ return new addColumnFamily_resultTupleScheme();
+ }
+ }
+
+ private static class addColumnFamily_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<addColumnFamily_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, addColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, addColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteColumnFamily_args implements org.apache.thrift.TBase<deleteColumnFamily_args, deleteColumnFamily_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteColumnFamily_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteColumnFamily_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.STRUCT, (short)1);
+ 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)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteColumnFamily_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteColumnFamily_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to delete column family from
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+ /**
+ * name of column family to be deleted
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to delete column family from
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * name of column family to be deleted
+ */
+ COLUMN((short)2, "column");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // COLUMN
+ return COLUMN;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteColumnFamily_args.class, metaDataMap);
+ }
+
+ public deleteColumnFamily_args() {
+ }
+
+ public deleteColumnFamily_args(
+ TTableName tableName,
+ java.nio.ByteBuffer column)
+ {
+ this();
+ this.tableName = tableName;
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteColumnFamily_args(deleteColumnFamily_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ if (other.isSetColumn()) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(other.column);
+ }
+ }
+
+ public deleteColumnFamily_args deepCopy() {
+ return new deleteColumnFamily_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.column = null;
+ }
+
+ /**
+ * the tablename to delete column family from
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to delete column family from
+ */
+ public deleteColumnFamily_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * name of column family to be deleted
+ */
+ public byte[] getColumn() {
+ setColumn(org.apache.thrift.TBaseHelper.rightSize(column));
+ return column == null ? null : column.array();
+ }
+
+ public java.nio.ByteBuffer bufferForColumn() {
+ return org.apache.thrift.TBaseHelper.copyBinary(column);
+ }
+
+ /**
+ * name of column family to be deleted
+ */
+ public deleteColumnFamily_args setColumn(byte[] column) {
+ this.column = column == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(column.clone());
+ return this;
+ }
+
+ public deleteColumnFamily_args setColumn(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer column) {
+ this.column = org.apache.thrift.TBaseHelper.copyBinary(column);
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ if (value instanceof byte[]) {
+ setColumn((byte[])value);
+ } else {
+ setColumn((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case COLUMN:
+ return getColumn();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case COLUMN:
+ return isSetColumn();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteColumnFamily_args)
+ return this.equals((deleteColumnFamily_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteColumnFamily_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteColumnFamily_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteColumnFamily_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.column, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ if (column == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'column' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteColumnFamily_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteColumnFamily_argsStandardScheme getScheme() {
+ return new deleteColumnFamily_argsStandardScheme();
+ }
+ }
+
+ private static class deleteColumnFamily_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteColumnFamily_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteColumnFamily_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ oprot.writeBinary(struct.column);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteColumnFamily_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteColumnFamily_argsTupleScheme getScheme() {
+ return new deleteColumnFamily_argsTupleScheme();
+ }
+ }
+
+ private static class deleteColumnFamily_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteColumnFamily_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ oprot.writeBinary(struct.column);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ struct.column = iprot.readBinary();
+ struct.setColumnIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteColumnFamily_result implements org.apache.thrift.TBase<deleteColumnFamily_result, deleteColumnFamily_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteColumnFamily_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteColumnFamily_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteColumnFamily_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteColumnFamily_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteColumnFamily_result.class, metaDataMap);
+ }
+
+ public deleteColumnFamily_result() {
+ }
+
+ public deleteColumnFamily_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteColumnFamily_result(deleteColumnFamily_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public deleteColumnFamily_result deepCopy() {
+ return new deleteColumnFamily_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public deleteColumnFamily_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteColumnFamily_result)
+ return this.equals((deleteColumnFamily_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteColumnFamily_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteColumnFamily_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteColumnFamily_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteColumnFamily_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteColumnFamily_resultStandardScheme getScheme() {
+ return new deleteColumnFamily_resultStandardScheme();
+ }
+ }
+
+ private static class deleteColumnFamily_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteColumnFamily_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteColumnFamily_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteColumnFamily_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteColumnFamily_resultTupleScheme getScheme() {
+ return new deleteColumnFamily_resultTupleScheme();
+ }
+ }
+
+ private static class deleteColumnFamily_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteColumnFamily_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class modifyColumnFamily_args implements org.apache.thrift.TBase<modifyColumnFamily_args, modifyColumnFamily_args._Fields>, java.io.Serializable, Cloneable, Comparable<modifyColumnFamily_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("modifyColumnFamily_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.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new modifyColumnFamily_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new modifyColumnFamily_argsTupleSchemeFactory();
+
+ /**
+ * the tablename to modify column family
+ */
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+ /**
+ * column family descriptor of column family to be modified
+ */
+ public @org.apache.thrift.annotation.Nullable TColumnFamilyDescriptor column; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the tablename to modify column family
+ */
+ TABLE_NAME((short)1, "tableName"),
+ /**
+ * column family descriptor of column family to be modified
+ */
+ COLUMN((short)2, "column");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // COLUMN
+ return COLUMN;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumnFamilyDescriptor.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(modifyColumnFamily_args.class, metaDataMap);
+ }
+
+ public modifyColumnFamily_args() {
+ }
+
+ public modifyColumnFamily_args(
+ TTableName tableName,
+ TColumnFamilyDescriptor column)
+ {
+ this();
+ this.tableName = tableName;
+ this.column = column;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public modifyColumnFamily_args(modifyColumnFamily_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ if (other.isSetColumn()) {
+ this.column = new TColumnFamilyDescriptor(other.column);
+ }
+ }
+
+ public modifyColumnFamily_args deepCopy() {
+ return new modifyColumnFamily_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.column = null;
+ }
+
+ /**
+ * the tablename to modify column family
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ /**
+ * the tablename to modify column family
+ */
+ public modifyColumnFamily_args setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ /**
+ * column family descriptor of column family to be modified
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TColumnFamilyDescriptor getColumn() {
+ return this.column;
+ }
+
+ /**
+ * column family descriptor of column family to be modified
+ */
+ public modifyColumnFamily_args setColumn(@org.apache.thrift.annotation.Nullable TColumnFamilyDescriptor column) {
+ this.column = column;
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ setColumn((TColumnFamilyDescriptor)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case COLUMN:
+ return getColumn();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case COLUMN:
+ return isSetColumn();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof modifyColumnFamily_args)
+ return this.equals((modifyColumnFamily_args)that);
+ return false;
+ }
+
+ public boolean equals(modifyColumnFamily_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_column = true && this.isSetColumn();
+ boolean that_present_column = true && that.isSetColumn();
+ if (this_present_column || that_present_column) {
+ if (!(this_present_column && that_present_column))
+ return false;
+ if (!this.column.equals(that.column))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumn()) ? 131071 : 524287);
+ if (isSetColumn())
+ hashCode = hashCode * 8191 + column.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(modifyColumnFamily_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumn(), other.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, other.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("modifyColumnFamily_args(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column:");
+ if (this.column == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.column);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ if (column == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'column' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ if (column != null) {
+ column.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class modifyColumnFamily_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyColumnFamily_argsStandardScheme getScheme() {
+ return new modifyColumnFamily_argsStandardScheme();
+ }
+ }
+
+ private static class modifyColumnFamily_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<modifyColumnFamily_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, modifyColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.column = new TColumnFamilyDescriptor();
+ struct.column.read(iprot);
+ struct.setColumnIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, modifyColumnFamily_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ struct.column.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class modifyColumnFamily_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyColumnFamily_argsTupleScheme getScheme() {
+ return new modifyColumnFamily_argsTupleScheme();
+ }
+ }
+
+ private static class modifyColumnFamily_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<modifyColumnFamily_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, modifyColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ struct.column.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, modifyColumnFamily_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ struct.column = new TColumnFamilyDescriptor();
+ struct.column.read(iprot);
+ struct.setColumnIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class modifyColumnFamily_result implements org.apache.thrift.TBase<modifyColumnFamily_result, modifyColumnFamily_result._Fields>, java.io.Serializable, Cloneable, Comparable<modifyColumnFamily_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("modifyColumnFamily_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new modifyColumnFamily_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new modifyColumnFamily_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(modifyColumnFamily_result.class, metaDataMap);
+ }
+
+ public modifyColumnFamily_result() {
+ }
+
+ public modifyColumnFamily_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public modifyColumnFamily_result(modifyColumnFamily_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public modifyColumnFamily_result deepCopy() {
+ return new modifyColumnFamily_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public modifyColumnFamily_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof modifyColumnFamily_result)
+ return this.equals((modifyColumnFamily_result)that);
+ return false;
+ }
+
+ public boolean equals(modifyColumnFamily_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(modifyColumnFamily_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("modifyColumnFamily_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class modifyColumnFamily_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyColumnFamily_resultStandardScheme getScheme() {
+ return new modifyColumnFamily_resultStandardScheme();
+ }
+ }
+
+ private static class modifyColumnFamily_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<modifyColumnFamily_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, modifyColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, modifyColumnFamily_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class modifyColumnFamily_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyColumnFamily_resultTupleScheme getScheme() {
+ return new modifyColumnFamily_resultTupleScheme();
+ }
+ }
+
+ private static class modifyColumnFamily_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<modifyColumnFamily_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, modifyColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, modifyColumnFamily_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class modifyTable_args implements org.apache.thrift.TBase<modifyTable_args, modifyTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<modifyTable_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("modifyTable_args");
+
+ private static final org.apache.thrift.protocol.TField DESC_FIELD_DESC = new org.apache.thrift.protocol.TField("desc", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new modifyTable_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new modifyTable_argsTupleSchemeFactory();
+
+ /**
+ * the descriptor of the table to modify
+ */
+ public @org.apache.thrift.annotation.Nullable TTableDescriptor desc; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * the descriptor of the table to modify
+ */
+ DESC((short)1, "desc");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // DESC
+ return DESC;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.DESC, new org.apache.thrift.meta_data.FieldMetaData("desc", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableDescriptor.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(modifyTable_args.class, metaDataMap);
+ }
+
+ public modifyTable_args() {
+ }
+
+ public modifyTable_args(
+ TTableDescriptor desc)
+ {
+ this();
+ this.desc = desc;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public modifyTable_args(modifyTable_args other) {
+ if (other.isSetDesc()) {
+ this.desc = new TTableDescriptor(other.desc);
+ }
+ }
+
+ public modifyTable_args deepCopy() {
+ return new modifyTable_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.desc = null;
+ }
+
+ /**
+ * the descriptor of the table to modify
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TTableDescriptor getDesc() {
+ return this.desc;
+ }
+
+ /**
+ * the descriptor of the table to modify
+ */
+ public modifyTable_args setDesc(@org.apache.thrift.annotation.Nullable TTableDescriptor desc) {
+ this.desc = desc;
+ return this;
+ }
+
+ public void unsetDesc() {
+ this.desc = null;
+ }
+
+ /** Returns true if field desc is set (has been assigned a value) and false otherwise */
+ public boolean isSetDesc() {
+ return this.desc != null;
+ }
+
+ public void setDescIsSet(boolean value) {
+ if (!value) {
+ this.desc = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case DESC:
+ if (value == null) {
+ unsetDesc();
+ } else {
+ setDesc((TTableDescriptor)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case DESC:
+ return getDesc();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case DESC:
+ return isSetDesc();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof modifyTable_args)
+ return this.equals((modifyTable_args)that);
+ return false;
+ }
+
+ public boolean equals(modifyTable_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_desc = true && this.isSetDesc();
+ boolean that_present_desc = true && that.isSetDesc();
+ if (this_present_desc || that_present_desc) {
+ if (!(this_present_desc && that_present_desc))
+ return false;
+ if (!this.desc.equals(that.desc))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetDesc()) ? 131071 : 524287);
+ if (isSetDesc())
+ hashCode = hashCode * 8191 + desc.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(modifyTable_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetDesc(), other.isSetDesc());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDesc()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.desc, other.desc);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("modifyTable_args(");
+ boolean first = true;
+
+ sb.append("desc:");
+ if (this.desc == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.desc);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (desc == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'desc' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (desc != null) {
+ desc.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class modifyTable_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyTable_argsStandardScheme getScheme() {
+ return new modifyTable_argsStandardScheme();
+ }
+ }
+
+ private static class modifyTable_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<modifyTable_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, modifyTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // DESC
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.desc = new TTableDescriptor();
+ struct.desc.read(iprot);
+ struct.setDescIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, modifyTable_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.desc != null) {
+ oprot.writeFieldBegin(DESC_FIELD_DESC);
+ struct.desc.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class modifyTable_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyTable_argsTupleScheme getScheme() {
+ return new modifyTable_argsTupleScheme();
+ }
+ }
+
+ private static class modifyTable_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<modifyTable_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, modifyTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.desc.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, modifyTable_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.desc = new TTableDescriptor();
+ struct.desc.read(iprot);
+ struct.setDescIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class modifyTable_result implements org.apache.thrift.TBase<modifyTable_result, modifyTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<modifyTable_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("modifyTable_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new modifyTable_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new modifyTable_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(modifyTable_result.class, metaDataMap);
+ }
+
+ public modifyTable_result() {
+ }
+
+ public modifyTable_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public modifyTable_result(modifyTable_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public modifyTable_result deepCopy() {
+ return new modifyTable_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public modifyTable_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof modifyTable_result)
+ return this.equals((modifyTable_result)that);
+ return false;
+ }
+
+ public boolean equals(modifyTable_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(modifyTable_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("modifyTable_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class modifyTable_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyTable_resultStandardScheme getScheme() {
+ return new modifyTable_resultStandardScheme();
+ }
+ }
+
+ private static class modifyTable_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<modifyTable_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, modifyTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, modifyTable_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class modifyTable_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyTable_resultTupleScheme getScheme() {
+ return new modifyTable_resultTupleScheme();
+ }
+ }
+
+ private static class modifyTable_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<modifyTable_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, modifyTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, modifyTable_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class createNamespace_args implements org.apache.thrift.TBase<createNamespace_args, createNamespace_args._Fields>, java.io.Serializable, Cloneable, Comparable<createNamespace_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createNamespace_args");
+
+ private static final org.apache.thrift.protocol.TField NAMESPACE_DESC_FIELD_DESC = new org.apache.thrift.protocol.TField("namespaceDesc", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new createNamespace_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new createNamespace_argsTupleSchemeFactory();
+
+ /**
+ * descriptor which describes the new namespace
+ */
+ public @org.apache.thrift.annotation.Nullable TNamespaceDescriptor namespaceDesc; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * descriptor which describes the new namespace
+ */
+ NAMESPACE_DESC((short)1, "namespaceDesc");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAMESPACE_DESC
+ return NAMESPACE_DESC;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAMESPACE_DESC, new org.apache.thrift.meta_data.FieldMetaData("namespaceDesc", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TNamespaceDescriptor.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createNamespace_args.class, metaDataMap);
+ }
+
+ public createNamespace_args() {
+ }
+
+ public createNamespace_args(
+ TNamespaceDescriptor namespaceDesc)
+ {
+ this();
+ this.namespaceDesc = namespaceDesc;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public createNamespace_args(createNamespace_args other) {
+ if (other.isSetNamespaceDesc()) {
+ this.namespaceDesc = new TNamespaceDescriptor(other.namespaceDesc);
+ }
+ }
+
+ public createNamespace_args deepCopy() {
+ return new createNamespace_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.namespaceDesc = null;
+ }
+
+ /**
+ * descriptor which describes the new namespace
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TNamespaceDescriptor getNamespaceDesc() {
+ return this.namespaceDesc;
+ }
+
+ /**
+ * descriptor which describes the new namespace
+ */
+ public createNamespace_args setNamespaceDesc(@org.apache.thrift.annotation.Nullable TNamespaceDescriptor namespaceDesc) {
+ this.namespaceDesc = namespaceDesc;
+ return this;
+ }
+
+ public void unsetNamespaceDesc() {
+ this.namespaceDesc = null;
+ }
+
+ /** Returns true if field namespaceDesc is set (has been assigned a value) and false otherwise */
+ public boolean isSetNamespaceDesc() {
+ return this.namespaceDesc != null;
+ }
+
+ public void setNamespaceDescIsSet(boolean value) {
+ if (!value) {
+ this.namespaceDesc = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAMESPACE_DESC:
+ if (value == null) {
+ unsetNamespaceDesc();
+ } else {
+ setNamespaceDesc((TNamespaceDescriptor)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAMESPACE_DESC:
+ return getNamespaceDesc();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAMESPACE_DESC:
+ return isSetNamespaceDesc();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof createNamespace_args)
+ return this.equals((createNamespace_args)that);
+ return false;
+ }
+
+ public boolean equals(createNamespace_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_namespaceDesc = true && this.isSetNamespaceDesc();
+ boolean that_present_namespaceDesc = true && that.isSetNamespaceDesc();
+ if (this_present_namespaceDesc || that_present_namespaceDesc) {
+ if (!(this_present_namespaceDesc && that_present_namespaceDesc))
+ return false;
+ if (!this.namespaceDesc.equals(that.namespaceDesc))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetNamespaceDesc()) ? 131071 : 524287);
+ if (isSetNamespaceDesc())
+ hashCode = hashCode * 8191 + namespaceDesc.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(createNamespace_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetNamespaceDesc(), other.isSetNamespaceDesc());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNamespaceDesc()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.namespaceDesc, other.namespaceDesc);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("createNamespace_args(");
+ boolean first = true;
+
+ sb.append("namespaceDesc:");
+ if (this.namespaceDesc == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.namespaceDesc);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (namespaceDesc == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'namespaceDesc' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (namespaceDesc != null) {
+ namespaceDesc.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class createNamespace_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createNamespace_argsStandardScheme getScheme() {
+ return new createNamespace_argsStandardScheme();
+ }
+ }
+
+ private static class createNamespace_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<createNamespace_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, createNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAMESPACE_DESC
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.namespaceDesc = new TNamespaceDescriptor();
+ struct.namespaceDesc.read(iprot);
+ struct.setNamespaceDescIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, createNamespace_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.namespaceDesc != null) {
+ oprot.writeFieldBegin(NAMESPACE_DESC_FIELD_DESC);
+ struct.namespaceDesc.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class createNamespace_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createNamespace_argsTupleScheme getScheme() {
+ return new createNamespace_argsTupleScheme();
+ }
+ }
+
+ private static class createNamespace_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<createNamespace_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, createNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.namespaceDesc.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, createNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.namespaceDesc = new TNamespaceDescriptor();
+ struct.namespaceDesc.read(iprot);
+ struct.setNamespaceDescIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class createNamespace_result implements org.apache.thrift.TBase<createNamespace_result, createNamespace_result._Fields>, java.io.Serializable, Cloneable, Comparable<createNamespace_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createNamespace_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new createNamespace_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new createNamespace_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createNamespace_result.class, metaDataMap);
+ }
+
+ public createNamespace_result() {
+ }
+
+ public createNamespace_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public createNamespace_result(createNamespace_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public createNamespace_result deepCopy() {
+ return new createNamespace_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public createNamespace_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof createNamespace_result)
+ return this.equals((createNamespace_result)that);
+ return false;
+ }
+
+ public boolean equals(createNamespace_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(createNamespace_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("createNamespace_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class createNamespace_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createNamespace_resultStandardScheme getScheme() {
+ return new createNamespace_resultStandardScheme();
+ }
+ }
+
+ private static class createNamespace_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<createNamespace_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, createNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, createNamespace_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class createNamespace_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public createNamespace_resultTupleScheme getScheme() {
+ return new createNamespace_resultTupleScheme();
+ }
+ }
+
+ private static class createNamespace_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<createNamespace_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, createNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, createNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class modifyNamespace_args implements org.apache.thrift.TBase<modifyNamespace_args, modifyNamespace_args._Fields>, java.io.Serializable, Cloneable, Comparable<modifyNamespace_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("modifyNamespace_args");
+
+ private static final org.apache.thrift.protocol.TField NAMESPACE_DESC_FIELD_DESC = new org.apache.thrift.protocol.TField("namespaceDesc", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new modifyNamespace_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new modifyNamespace_argsTupleSchemeFactory();
+
+ /**
+ * descriptor which describes the new namespace
+ */
+ public @org.apache.thrift.annotation.Nullable TNamespaceDescriptor namespaceDesc; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * descriptor which describes the new namespace
+ */
+ NAMESPACE_DESC((short)1, "namespaceDesc");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAMESPACE_DESC
+ return NAMESPACE_DESC;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAMESPACE_DESC, new org.apache.thrift.meta_data.FieldMetaData("namespaceDesc", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TNamespaceDescriptor.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(modifyNamespace_args.class, metaDataMap);
+ }
+
+ public modifyNamespace_args() {
+ }
+
+ public modifyNamespace_args(
+ TNamespaceDescriptor namespaceDesc)
+ {
+ this();
+ this.namespaceDesc = namespaceDesc;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public modifyNamespace_args(modifyNamespace_args other) {
+ if (other.isSetNamespaceDesc()) {
+ this.namespaceDesc = new TNamespaceDescriptor(other.namespaceDesc);
+ }
+ }
+
+ public modifyNamespace_args deepCopy() {
+ return new modifyNamespace_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.namespaceDesc = null;
+ }
+
+ /**
+ * descriptor which describes the new namespace
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TNamespaceDescriptor getNamespaceDesc() {
+ return this.namespaceDesc;
+ }
+
+ /**
+ * descriptor which describes the new namespace
+ */
+ public modifyNamespace_args setNamespaceDesc(@org.apache.thrift.annotation.Nullable TNamespaceDescriptor namespaceDesc) {
+ this.namespaceDesc = namespaceDesc;
+ return this;
+ }
+
+ public void unsetNamespaceDesc() {
+ this.namespaceDesc = null;
+ }
+
+ /** Returns true if field namespaceDesc is set (has been assigned a value) and false otherwise */
+ public boolean isSetNamespaceDesc() {
+ return this.namespaceDesc != null;
+ }
+
+ public void setNamespaceDescIsSet(boolean value) {
+ if (!value) {
+ this.namespaceDesc = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAMESPACE_DESC:
+ if (value == null) {
+ unsetNamespaceDesc();
+ } else {
+ setNamespaceDesc((TNamespaceDescriptor)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAMESPACE_DESC:
+ return getNamespaceDesc();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAMESPACE_DESC:
+ return isSetNamespaceDesc();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof modifyNamespace_args)
+ return this.equals((modifyNamespace_args)that);
+ return false;
+ }
+
+ public boolean equals(modifyNamespace_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_namespaceDesc = true && this.isSetNamespaceDesc();
+ boolean that_present_namespaceDesc = true && that.isSetNamespaceDesc();
+ if (this_present_namespaceDesc || that_present_namespaceDesc) {
+ if (!(this_present_namespaceDesc && that_present_namespaceDesc))
+ return false;
+ if (!this.namespaceDesc.equals(that.namespaceDesc))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetNamespaceDesc()) ? 131071 : 524287);
+ if (isSetNamespaceDesc())
+ hashCode = hashCode * 8191 + namespaceDesc.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(modifyNamespace_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetNamespaceDesc(), other.isSetNamespaceDesc());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNamespaceDesc()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.namespaceDesc, other.namespaceDesc);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("modifyNamespace_args(");
+ boolean first = true;
+
+ sb.append("namespaceDesc:");
+ if (this.namespaceDesc == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.namespaceDesc);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (namespaceDesc == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'namespaceDesc' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (namespaceDesc != null) {
+ namespaceDesc.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class modifyNamespace_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyNamespace_argsStandardScheme getScheme() {
+ return new modifyNamespace_argsStandardScheme();
+ }
+ }
+
+ private static class modifyNamespace_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<modifyNamespace_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, modifyNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAMESPACE_DESC
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.namespaceDesc = new TNamespaceDescriptor();
+ struct.namespaceDesc.read(iprot);
+ struct.setNamespaceDescIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, modifyNamespace_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.namespaceDesc != null) {
+ oprot.writeFieldBegin(NAMESPACE_DESC_FIELD_DESC);
+ struct.namespaceDesc.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class modifyNamespace_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyNamespace_argsTupleScheme getScheme() {
+ return new modifyNamespace_argsTupleScheme();
+ }
+ }
+
+ private static class modifyNamespace_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<modifyNamespace_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, modifyNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.namespaceDesc.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, modifyNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.namespaceDesc = new TNamespaceDescriptor();
+ struct.namespaceDesc.read(iprot);
+ struct.setNamespaceDescIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class modifyNamespace_result implements org.apache.thrift.TBase<modifyNamespace_result, modifyNamespace_result._Fields>, java.io.Serializable, Cloneable, Comparable<modifyNamespace_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("modifyNamespace_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new modifyNamespace_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new modifyNamespace_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(modifyNamespace_result.class, metaDataMap);
+ }
+
+ public modifyNamespace_result() {
+ }
+
+ public modifyNamespace_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public modifyNamespace_result(modifyNamespace_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public modifyNamespace_result deepCopy() {
+ return new modifyNamespace_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public modifyNamespace_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof modifyNamespace_result)
+ return this.equals((modifyNamespace_result)that);
+ return false;
+ }
+
+ public boolean equals(modifyNamespace_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(modifyNamespace_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("modifyNamespace_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class modifyNamespace_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyNamespace_resultStandardScheme getScheme() {
+ return new modifyNamespace_resultStandardScheme();
+ }
+ }
+
+ private static class modifyNamespace_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<modifyNamespace_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, modifyNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, modifyNamespace_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class modifyNamespace_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public modifyNamespace_resultTupleScheme getScheme() {
+ return new modifyNamespace_resultTupleScheme();
+ }
+ }
+
+ private static class modifyNamespace_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<modifyNamespace_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, modifyNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, modifyNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteNamespace_args implements org.apache.thrift.TBase<deleteNamespace_args, deleteNamespace_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteNamespace_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteNamespace_args");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteNamespace_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteNamespace_argsTupleSchemeFactory();
+
+ /**
+ * namespace name
+ */
+ public @org.apache.thrift.annotation.Nullable java.lang.String name; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * namespace name
+ */
+ NAME((short)1, "name");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteNamespace_args.class, metaDataMap);
+ }
+
+ public deleteNamespace_args() {
+ }
+
+ public deleteNamespace_args(
+ java.lang.String name)
+ {
+ this();
+ this.name = name;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteNamespace_args(deleteNamespace_args other) {
+ if (other.isSetName()) {
+ this.name = other.name;
+ }
+ }
+
+ public deleteNamespace_args deepCopy() {
+ return new deleteNamespace_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ }
+
+ /**
+ * namespace name
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getName() {
+ return this.name;
+ }
+
+ /**
+ * namespace name
+ */
+ public deleteNamespace_args setName(@org.apache.thrift.annotation.Nullable java.lang.String name) {
+ this.name = name;
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ setName((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteNamespace_args)
+ return this.equals((deleteNamespace_args)that);
+ return false;
+ }
+
+ public boolean equals(deleteNamespace_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteNamespace_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteNamespace_args(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.name);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (name == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteNamespace_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteNamespace_argsStandardScheme getScheme() {
+ return new deleteNamespace_argsStandardScheme();
+ }
+ }
+
+ private static class deleteNamespace_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteNamespace_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteNamespace_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeString(struct.name);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteNamespace_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteNamespace_argsTupleScheme getScheme() {
+ return new deleteNamespace_argsTupleScheme();
+ }
+ }
+
+ private static class deleteNamespace_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteNamespace_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.name);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteNamespace_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class deleteNamespace_result implements org.apache.thrift.TBase<deleteNamespace_result, deleteNamespace_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteNamespace_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteNamespace_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new deleteNamespace_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new deleteNamespace_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteNamespace_result.class, metaDataMap);
+ }
+
+ public deleteNamespace_result() {
+ }
+
+ public deleteNamespace_result(
+ TIOError io)
+ {
+ this();
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public deleteNamespace_result(deleteNamespace_result other) {
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public deleteNamespace_result deepCopy() {
+ return new deleteNamespace_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public deleteNamespace_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof deleteNamespace_result)
+ return this.equals((deleteNamespace_result)that);
+ return false;
+ }
+
+ public boolean equals(deleteNamespace_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(deleteNamespace_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("deleteNamespace_result(");
+ boolean first = true;
+
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class deleteNamespace_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteNamespace_resultStandardScheme getScheme() {
+ return new deleteNamespace_resultStandardScheme();
+ }
+ }
+
+ private static class deleteNamespace_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<deleteNamespace_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, deleteNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, deleteNamespace_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class deleteNamespace_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public deleteNamespace_resultTupleScheme getScheme() {
+ return new deleteNamespace_resultTupleScheme();
+ }
+ }
+
+ private static class deleteNamespace_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<deleteNamespace_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, deleteNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetIo()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, deleteNamespace_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getNamespaceDescriptor_args implements org.apache.thrift.TBase<getNamespaceDescriptor_args, getNamespaceDescriptor_args._Fields>, java.io.Serializable, Cloneable, Comparable<getNamespaceDescriptor_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getNamespaceDescriptor_args");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getNamespaceDescriptor_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getNamespaceDescriptor_argsTupleSchemeFactory();
+
+ /**
+ * name of namespace descriptor
+ */
+ public @org.apache.thrift.annotation.Nullable java.lang.String name; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * name of namespace descriptor
+ */
+ NAME((short)1, "name");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getNamespaceDescriptor_args.class, metaDataMap);
+ }
+
+ public getNamespaceDescriptor_args() {
+ }
+
+ public getNamespaceDescriptor_args(
+ java.lang.String name)
+ {
+ this();
+ this.name = name;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getNamespaceDescriptor_args(getNamespaceDescriptor_args other) {
+ if (other.isSetName()) {
+ this.name = other.name;
+ }
+ }
+
+ public getNamespaceDescriptor_args deepCopy() {
+ return new getNamespaceDescriptor_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ }
+
+ /**
+ * name of namespace descriptor
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getName() {
+ return this.name;
+ }
+
+ /**
+ * name of namespace descriptor
+ */
+ public getNamespaceDescriptor_args setName(@org.apache.thrift.annotation.Nullable java.lang.String name) {
+ this.name = name;
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ setName((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getNamespaceDescriptor_args)
+ return this.equals((getNamespaceDescriptor_args)that);
+ return false;
+ }
+
+ public boolean equals(getNamespaceDescriptor_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getNamespaceDescriptor_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getNamespaceDescriptor_args(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.name);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (name == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getNamespaceDescriptor_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getNamespaceDescriptor_argsStandardScheme getScheme() {
+ return new getNamespaceDescriptor_argsStandardScheme();
+ }
+ }
+
+ private static class getNamespaceDescriptor_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getNamespaceDescriptor_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getNamespaceDescriptor_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getNamespaceDescriptor_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeString(struct.name);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getNamespaceDescriptor_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getNamespaceDescriptor_argsTupleScheme getScheme() {
+ return new getNamespaceDescriptor_argsTupleScheme();
+ }
+ }
+
+ private static class getNamespaceDescriptor_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getNamespaceDescriptor_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getNamespaceDescriptor_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.name);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getNamespaceDescriptor_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getNamespaceDescriptor_result implements org.apache.thrift.TBase<getNamespaceDescriptor_result, getNamespaceDescriptor_result._Fields>, java.io.Serializable, Cloneable, Comparable<getNamespaceDescriptor_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getNamespaceDescriptor_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+ private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getNamespaceDescriptor_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getNamespaceDescriptor_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TNamespaceDescriptor success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TNamespaceDescriptor.class)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getNamespaceDescriptor_result.class, metaDataMap);
+ }
+
+ public getNamespaceDescriptor_result() {
+ }
+
+ public getNamespaceDescriptor_result(
+ TNamespaceDescriptor success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getNamespaceDescriptor_result(getNamespaceDescriptor_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TNamespaceDescriptor(other.success);
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getNamespaceDescriptor_result deepCopy() {
+ return new getNamespaceDescriptor_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TNamespaceDescriptor getSuccess() {
+ return this.success;
+ }
+
+ public getNamespaceDescriptor_result setSuccess(@org.apache.thrift.annotation.Nullable TNamespaceDescriptor success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getNamespaceDescriptor_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TNamespaceDescriptor)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getNamespaceDescriptor_result)
+ return this.equals((getNamespaceDescriptor_result)that);
+ return false;
+ }
+
+ public boolean equals(getNamespaceDescriptor_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getNamespaceDescriptor_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getNamespaceDescriptor_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getNamespaceDescriptor_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getNamespaceDescriptor_resultStandardScheme getScheme() {
+ return new getNamespaceDescriptor_resultStandardScheme();
+ }
+ }
+
+ private static class getNamespaceDescriptor_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getNamespaceDescriptor_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getNamespaceDescriptor_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TNamespaceDescriptor();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getNamespaceDescriptor_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getNamespaceDescriptor_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getNamespaceDescriptor_resultTupleScheme getScheme() {
+ return new getNamespaceDescriptor_resultTupleScheme();
+ }
+ }
+
+ private static class getNamespaceDescriptor_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getNamespaceDescriptor_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getNamespaceDescriptor_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getNamespaceDescriptor_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = new TNamespaceDescriptor();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class listNamespaceDescriptors_args implements org.apache.thrift.TBase<listNamespaceDescriptors_args, listNamespaceDescriptors_args._Fields>, java.io.Serializable, Cloneable, Comparable<listNamespaceDescriptors_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("listNamespaceDescriptors_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new listNamespaceDescriptors_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new listNamespaceDescriptors_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(listNamespaceDescriptors_args.class, metaDataMap);
+ }
+
+ public listNamespaceDescriptors_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public listNamespaceDescriptors_args(listNamespaceDescriptors_args other) {
+ }
+
+ public listNamespaceDescriptors_args deepCopy() {
+ return new listNamespaceDescriptors_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof listNamespaceDescriptors_args)
+ return this.equals((listNamespaceDescriptors_args)that);
+ return false;
+ }
+
+ public boolean equals(listNamespaceDescriptors_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(listNamespaceDescriptors_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("listNamespaceDescriptors_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class listNamespaceDescriptors_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaceDescriptors_argsStandardScheme getScheme() {
+ return new listNamespaceDescriptors_argsStandardScheme();
+ }
+ }
+
+ private static class listNamespaceDescriptors_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<listNamespaceDescriptors_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, listNamespaceDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, listNamespaceDescriptors_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class listNamespaceDescriptors_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaceDescriptors_argsTupleScheme getScheme() {
+ return new listNamespaceDescriptors_argsTupleScheme();
+ }
+ }
+
+ private static class listNamespaceDescriptors_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<listNamespaceDescriptors_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, listNamespaceDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, listNamespaceDescriptors_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class listNamespaceDescriptors_result implements org.apache.thrift.TBase<listNamespaceDescriptors_result, listNamespaceDescriptors_result._Fields>, java.io.Serializable, Cloneable, Comparable<listNamespaceDescriptors_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("listNamespaceDescriptors_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new listNamespaceDescriptors_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new listNamespaceDescriptors_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TNamespaceDescriptor> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TNamespaceDescriptor.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(listNamespaceDescriptors_result.class, metaDataMap);
+ }
+
+ public listNamespaceDescriptors_result() {
+ }
+
+ public listNamespaceDescriptors_result(
+ java.util.List<TNamespaceDescriptor> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public listNamespaceDescriptors_result(listNamespaceDescriptors_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TNamespaceDescriptor> __this__success = new java.util.ArrayList<TNamespaceDescriptor>(other.success.size());
+ for (TNamespaceDescriptor other_element : other.success) {
+ __this__success.add(new TNamespaceDescriptor(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public listNamespaceDescriptors_result deepCopy() {
+ return new listNamespaceDescriptors_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TNamespaceDescriptor> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TNamespaceDescriptor elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TNamespaceDescriptor>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TNamespaceDescriptor> getSuccess() {
+ return this.success;
+ }
+
+ public listNamespaceDescriptors_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TNamespaceDescriptor> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public listNamespaceDescriptors_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TNamespaceDescriptor>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof listNamespaceDescriptors_result)
+ return this.equals((listNamespaceDescriptors_result)that);
+ return false;
+ }
+
+ public boolean equals(listNamespaceDescriptors_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(listNamespaceDescriptors_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("listNamespaceDescriptors_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class listNamespaceDescriptors_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaceDescriptors_resultStandardScheme getScheme() {
+ return new listNamespaceDescriptors_resultStandardScheme();
+ }
+ }
+
+ private static class listNamespaceDescriptors_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<listNamespaceDescriptors_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, listNamespaceDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list334 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TNamespaceDescriptor>(_list334.size);
+ @org.apache.thrift.annotation.Nullable TNamespaceDescriptor _elem335;
+ for (int _i336 = 0; _i336 < _list334.size; ++_i336)
+ {
+ _elem335 = new TNamespaceDescriptor();
+ _elem335.read(iprot);
+ struct.success.add(_elem335);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, listNamespaceDescriptors_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TNamespaceDescriptor _iter337 : struct.success)
+ {
+ _iter337.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class listNamespaceDescriptors_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaceDescriptors_resultTupleScheme getScheme() {
+ return new listNamespaceDescriptors_resultTupleScheme();
+ }
+ }
+
+ private static class listNamespaceDescriptors_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<listNamespaceDescriptors_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, listNamespaceDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TNamespaceDescriptor _iter338 : struct.success)
+ {
+ _iter338.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, listNamespaceDescriptors_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list339 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TNamespaceDescriptor>(_list339.size);
+ @org.apache.thrift.annotation.Nullable TNamespaceDescriptor _elem340;
+ for (int _i341 = 0; _i341 < _list339.size; ++_i341)
+ {
+ _elem340 = new TNamespaceDescriptor();
+ _elem340.read(iprot);
+ struct.success.add(_elem340);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class listNamespaces_args implements org.apache.thrift.TBase<listNamespaces_args, listNamespaces_args._Fields>, java.io.Serializable, Cloneable, Comparable<listNamespaces_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("listNamespaces_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new listNamespaces_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new listNamespaces_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(listNamespaces_args.class, metaDataMap);
+ }
+
+ public listNamespaces_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public listNamespaces_args(listNamespaces_args other) {
+ }
+
+ public listNamespaces_args deepCopy() {
+ return new listNamespaces_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof listNamespaces_args)
+ return this.equals((listNamespaces_args)that);
+ return false;
+ }
+
+ public boolean equals(listNamespaces_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(listNamespaces_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("listNamespaces_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class listNamespaces_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaces_argsStandardScheme getScheme() {
+ return new listNamespaces_argsStandardScheme();
+ }
+ }
+
+ private static class listNamespaces_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<listNamespaces_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, listNamespaces_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, listNamespaces_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class listNamespaces_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaces_argsTupleScheme getScheme() {
+ return new listNamespaces_argsTupleScheme();
+ }
+ }
+
+ private static class listNamespaces_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<listNamespaces_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, listNamespaces_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, listNamespaces_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class listNamespaces_result implements org.apache.thrift.TBase<listNamespaces_result, listNamespaces_result._Fields>, java.io.Serializable, Cloneable, Comparable<listNamespaces_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("listNamespaces_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new listNamespaces_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new listNamespaces_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(listNamespaces_result.class, metaDataMap);
+ }
+
+ public listNamespaces_result() {
+ }
+
+ public listNamespaces_result(
+ java.util.List<java.lang.String> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public listNamespaces_result(listNamespaces_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<java.lang.String> __this__success = new java.util.ArrayList<java.lang.String>(other.success);
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public listNamespaces_result deepCopy() {
+ return new listNamespaces_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.lang.String> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(java.lang.String elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<java.lang.String>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.lang.String> getSuccess() {
+ return this.success;
+ }
+
+ public listNamespaces_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public listNamespaces_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<java.lang.String>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof listNamespaces_result)
+ return this.equals((listNamespaces_result)that);
+ return false;
+ }
+
+ public boolean equals(listNamespaces_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(listNamespaces_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("listNamespaces_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class listNamespaces_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaces_resultStandardScheme getScheme() {
+ return new listNamespaces_resultStandardScheme();
+ }
+ }
+
+ private static class listNamespaces_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<listNamespaces_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, listNamespaces_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list342 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<java.lang.String>(_list342.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem343;
+ for (int _i344 = 0; _i344 < _list342.size; ++_i344)
+ {
+ _elem343 = iprot.readString();
+ struct.success.add(_elem343);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, listNamespaces_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size()));
+ for (java.lang.String _iter345 : struct.success)
+ {
+ oprot.writeString(_iter345);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class listNamespaces_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public listNamespaces_resultTupleScheme getScheme() {
+ return new listNamespaces_resultTupleScheme();
+ }
+ }
+
+ private static class listNamespaces_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<listNamespaces_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, listNamespaces_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (java.lang.String _iter346 : struct.success)
+ {
+ oprot.writeString(_iter346);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, listNamespaces_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list347 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.success = new java.util.ArrayList<java.lang.String>(_list347.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem348;
+ for (int _i349 = 0; _i349 < _list347.size; ++_i349)
+ {
+ _elem348 = iprot.readString();
+ struct.success.add(_elem348);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getThriftServerType_args implements org.apache.thrift.TBase<getThriftServerType_args, getThriftServerType_args._Fields>, java.io.Serializable, Cloneable, Comparable<getThriftServerType_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getThriftServerType_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getThriftServerType_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getThriftServerType_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getThriftServerType_args.class, metaDataMap);
+ }
+
+ public getThriftServerType_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getThriftServerType_args(getThriftServerType_args other) {
+ }
+
+ public getThriftServerType_args deepCopy() {
+ return new getThriftServerType_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getThriftServerType_args)
+ return this.equals((getThriftServerType_args)that);
+ return false;
+ }
+
+ public boolean equals(getThriftServerType_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getThriftServerType_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getThriftServerType_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getThriftServerType_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_argsStandardScheme getScheme() {
+ return new getThriftServerType_argsStandardScheme();
+ }
+ }
+
+ private static class getThriftServerType_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getThriftServerType_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getThriftServerType_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_argsTupleScheme getScheme() {
+ return new getThriftServerType_argsTupleScheme();
+ }
+ }
+
+ private static class getThriftServerType_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getThriftServerType_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getThriftServerType_result implements org.apache.thrift.TBase<getThriftServerType_result, getThriftServerType_result._Fields>, java.io.Serializable, Cloneable, Comparable<getThriftServerType_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getThriftServerType_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getThriftServerType_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getThriftServerType_resultTupleSchemeFactory();
+
+ /**
+ *
+ * @see TThriftServerType
+ */
+ public @org.apache.thrift.annotation.Nullable TThriftServerType success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ *
+ * @see TThriftServerType
+ */
+ SUCCESS((short)0, "success");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TThriftServerType.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getThriftServerType_result.class, metaDataMap);
+ }
+
+ public getThriftServerType_result() {
+ }
+
+ public getThriftServerType_result(
+ TThriftServerType success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getThriftServerType_result(getThriftServerType_result other) {
+ if (other.isSetSuccess()) {
+ this.success = other.success;
+ }
+ }
+
+ public getThriftServerType_result deepCopy() {
+ return new getThriftServerType_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ /**
+ *
+ * @see TThriftServerType
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TThriftServerType getSuccess() {
+ return this.success;
+ }
+
+ /**
+ *
+ * @see TThriftServerType
+ */
+ public getThriftServerType_result setSuccess(@org.apache.thrift.annotation.Nullable TThriftServerType success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TThriftServerType)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getThriftServerType_result)
+ return this.equals((getThriftServerType_result)that);
+ return false;
+ }
+
+ public boolean equals(getThriftServerType_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.getValue();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getThriftServerType_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getThriftServerType_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getThriftServerType_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_resultStandardScheme getScheme() {
+ return new getThriftServerType_resultStandardScheme();
+ }
+ }
+
+ private static class getThriftServerType_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getThriftServerType_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.success = org.apache.hadoop.hbase.thrift2.generated.TThriftServerType.findByValue(iprot.readI32());
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeI32(struct.success.getValue());
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getThriftServerType_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getThriftServerType_resultTupleScheme getScheme() {
+ return new getThriftServerType_resultTupleScheme();
+ }
+ }
+
+ private static class getThriftServerType_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getThriftServerType_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ oprot.writeI32(struct.success.getValue());
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getThriftServerType_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = org.apache.hadoop.hbase.thrift2.generated.TThriftServerType.findByValue(iprot.readI32());
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getClusterId_args implements org.apache.thrift.TBase<getClusterId_args, getClusterId_args._Fields>, java.io.Serializable, Cloneable, Comparable<getClusterId_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getClusterId_args");
+
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getClusterId_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getClusterId_argsTupleSchemeFactory();
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getClusterId_args.class, metaDataMap);
+ }
+
+ public getClusterId_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getClusterId_args(getClusterId_args other) {
+ }
+
+ public getClusterId_args deepCopy() {
+ return new getClusterId_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getClusterId_args)
+ return this.equals((getClusterId_args)that);
+ return false;
+ }
+
+ public boolean equals(getClusterId_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getClusterId_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getClusterId_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getClusterId_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_argsStandardScheme getScheme() {
+ return new getClusterId_argsStandardScheme();
+ }
+ }
+
+ private static class getClusterId_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getClusterId_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getClusterId_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getClusterId_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getClusterId_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_argsTupleScheme getScheme() {
+ return new getClusterId_argsTupleScheme();
+ }
+ }
+
+ private static class getClusterId_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getClusterId_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getClusterId_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getClusterId_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getClusterId_result implements org.apache.thrift.TBase<getClusterId_result, getClusterId_result._Fields>, java.io.Serializable, Cloneable, Comparable<getClusterId_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getClusterId_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRING, (short)0);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getClusterId_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getClusterId_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getClusterId_result.class, metaDataMap);
+ }
+
+ public getClusterId_result() {
+ }
+
+ public getClusterId_result(
+ java.lang.String success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getClusterId_result(getClusterId_result other) {
+ if (other.isSetSuccess()) {
+ this.success = other.success;
+ }
+ }
+
+ public getClusterId_result deepCopy() {
+ return new getClusterId_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getSuccess() {
+ return this.success;
+ }
+
+ public getClusterId_result setSuccess(@org.apache.thrift.annotation.Nullable java.lang.String success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getClusterId_result)
+ return this.equals((getClusterId_result)that);
+ return false;
+ }
+
+ public boolean equals(getClusterId_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getClusterId_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getClusterId_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getClusterId_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_resultStandardScheme getScheme() {
+ return new getClusterId_resultStandardScheme();
+ }
+ }
+
+ private static class getClusterId_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getClusterId_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getClusterId_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.success = iprot.readString();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getClusterId_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeString(struct.success);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getClusterId_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getClusterId_resultTupleScheme getScheme() {
+ return new getClusterId_resultTupleScheme();
+ }
+ }
+
+ private static class getClusterId_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getClusterId_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getClusterId_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ oprot.writeString(struct.success);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getClusterId_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = iprot.readString();
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getSlowLogResponses_args implements org.apache.thrift.TBase<getSlowLogResponses_args, getSlowLogResponses_args._Fields>, java.io.Serializable, Cloneable, Comparable<getSlowLogResponses_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getSlowLogResponses_args");
+
+ private static final org.apache.thrift.protocol.TField SERVER_NAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("serverNames", org.apache.thrift.protocol.TType.SET, (short)1);
+ private static final org.apache.thrift.protocol.TField LOG_QUERY_FILTER_FIELD_DESC = new org.apache.thrift.protocol.TField("logQueryFilter", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getSlowLogResponses_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getSlowLogResponses_argsTupleSchemeFactory();
+
+ /**
+ * @param serverNames Server names to get slowlog responses from
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Set<TServerName> serverNames; // required
+ /**
+ * @param logQueryFilter filter to be used if provided
+ */
+ public @org.apache.thrift.annotation.Nullable TLogQueryFilter logQueryFilter; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * @param serverNames Server names to get slowlog responses from
+ */
+ SERVER_NAMES((short)1, "serverNames"),
+ /**
+ * @param logQueryFilter filter to be used if provided
+ */
+ LOG_QUERY_FILTER((short)2, "logQueryFilter");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // SERVER_NAMES
+ return SERVER_NAMES;
+ case 2: // LOG_QUERY_FILTER
+ return LOG_QUERY_FILTER;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SERVER_NAMES, new org.apache.thrift.meta_data.FieldMetaData("serverNames", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TServerName.class))));
+ tmpMap.put(_Fields.LOG_QUERY_FILTER, new org.apache.thrift.meta_data.FieldMetaData("logQueryFilter", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TLogQueryFilter.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getSlowLogResponses_args.class, metaDataMap);
+ }
+
+ public getSlowLogResponses_args() {
+ }
+
+ public getSlowLogResponses_args(
+ java.util.Set<TServerName> serverNames,
+ TLogQueryFilter logQueryFilter)
+ {
+ this();
+ this.serverNames = serverNames;
+ this.logQueryFilter = logQueryFilter;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getSlowLogResponses_args(getSlowLogResponses_args other) {
+ if (other.isSetServerNames()) {
+ java.util.Set<TServerName> __this__serverNames = new java.util.HashSet<TServerName>(other.serverNames.size());
+ for (TServerName other_element : other.serverNames) {
+ __this__serverNames.add(new TServerName(other_element));
+ }
+ this.serverNames = __this__serverNames;
+ }
+ if (other.isSetLogQueryFilter()) {
+ this.logQueryFilter = new TLogQueryFilter(other.logQueryFilter);
+ }
+ }
+
+ public getSlowLogResponses_args deepCopy() {
+ return new getSlowLogResponses_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.serverNames = null;
+ this.logQueryFilter = null;
+ }
+
+ public int getServerNamesSize() {
+ return (this.serverNames == null) ? 0 : this.serverNames.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TServerName> getServerNamesIterator() {
+ return (this.serverNames == null) ? null : this.serverNames.iterator();
+ }
+
+ public void addToServerNames(TServerName elem) {
+ if (this.serverNames == null) {
+ this.serverNames = new java.util.HashSet<TServerName>();
+ }
+ this.serverNames.add(elem);
+ }
+
+ /**
+ * @param serverNames Server names to get slowlog responses from
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Set<TServerName> getServerNames() {
+ return this.serverNames;
+ }
+
+ /**
+ * @param serverNames Server names to get slowlog responses from
+ */
+ public getSlowLogResponses_args setServerNames(@org.apache.thrift.annotation.Nullable java.util.Set<TServerName> serverNames) {
+ this.serverNames = serverNames;
+ return this;
+ }
+
+ public void unsetServerNames() {
+ this.serverNames = null;
+ }
+
+ /** Returns true if field serverNames is set (has been assigned a value) and false otherwise */
+ public boolean isSetServerNames() {
+ return this.serverNames != null;
+ }
+
+ public void setServerNamesIsSet(boolean value) {
+ if (!value) {
+ this.serverNames = null;
+ }
+ }
+
+ /**
+ * @param logQueryFilter filter to be used if provided
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TLogQueryFilter getLogQueryFilter() {
+ return this.logQueryFilter;
+ }
+
+ /**
+ * @param logQueryFilter filter to be used if provided
+ */
+ public getSlowLogResponses_args setLogQueryFilter(@org.apache.thrift.annotation.Nullable TLogQueryFilter logQueryFilter) {
+ this.logQueryFilter = logQueryFilter;
+ return this;
+ }
+
+ public void unsetLogQueryFilter() {
+ this.logQueryFilter = null;
+ }
+
+ /** Returns true if field logQueryFilter is set (has been assigned a value) and false otherwise */
+ public boolean isSetLogQueryFilter() {
+ return this.logQueryFilter != null;
+ }
+
+ public void setLogQueryFilterIsSet(boolean value) {
+ if (!value) {
+ this.logQueryFilter = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SERVER_NAMES:
+ if (value == null) {
+ unsetServerNames();
+ } else {
+ setServerNames((java.util.Set<TServerName>)value);
+ }
+ break;
+
+ case LOG_QUERY_FILTER:
+ if (value == null) {
+ unsetLogQueryFilter();
+ } else {
+ setLogQueryFilter((TLogQueryFilter)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SERVER_NAMES:
+ return getServerNames();
+
+ case LOG_QUERY_FILTER:
+ return getLogQueryFilter();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SERVER_NAMES:
+ return isSetServerNames();
+ case LOG_QUERY_FILTER:
+ return isSetLogQueryFilter();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getSlowLogResponses_args)
+ return this.equals((getSlowLogResponses_args)that);
+ return false;
+ }
+
+ public boolean equals(getSlowLogResponses_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_serverNames = true && this.isSetServerNames();
+ boolean that_present_serverNames = true && that.isSetServerNames();
+ if (this_present_serverNames || that_present_serverNames) {
+ if (!(this_present_serverNames && that_present_serverNames))
+ return false;
+ if (!this.serverNames.equals(that.serverNames))
+ return false;
+ }
+
+ boolean this_present_logQueryFilter = true && this.isSetLogQueryFilter();
+ boolean that_present_logQueryFilter = true && that.isSetLogQueryFilter();
+ if (this_present_logQueryFilter || that_present_logQueryFilter) {
+ if (!(this_present_logQueryFilter && that_present_logQueryFilter))
+ return false;
+ if (!this.logQueryFilter.equals(that.logQueryFilter))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetServerNames()) ? 131071 : 524287);
+ if (isSetServerNames())
+ hashCode = hashCode * 8191 + serverNames.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetLogQueryFilter()) ? 131071 : 524287);
+ if (isSetLogQueryFilter())
+ hashCode = hashCode * 8191 + logQueryFilter.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getSlowLogResponses_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetServerNames(), other.isSetServerNames());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetServerNames()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverNames, other.serverNames);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetLogQueryFilter(), other.isSetLogQueryFilter());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetLogQueryFilter()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.logQueryFilter, other.logQueryFilter);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getSlowLogResponses_args(");
+ boolean first = true;
+
+ sb.append("serverNames:");
+ if (this.serverNames == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.serverNames);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("logQueryFilter:");
+ if (this.logQueryFilter == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.logQueryFilter);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (logQueryFilter != null) {
+ logQueryFilter.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getSlowLogResponses_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getSlowLogResponses_argsStandardScheme getScheme() {
+ return new getSlowLogResponses_argsStandardScheme();
+ }
+ }
+
+ private static class getSlowLogResponses_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<getSlowLogResponses_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // SERVER_NAMES
+ if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
+ {
+ org.apache.thrift.protocol.TSet _set350 = iprot.readSetBegin();
+ struct.serverNames = new java.util.HashSet<TServerName>(2*_set350.size);
+ @org.apache.thrift.annotation.Nullable TServerName _elem351;
+ for (int _i352 = 0; _i352 < _set350.size; ++_i352)
+ {
+ _elem351 = new TServerName();
+ _elem351.read(iprot);
+ struct.serverNames.add(_elem351);
+ }
+ iprot.readSetEnd();
+ }
+ struct.setServerNamesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // LOG_QUERY_FILTER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.logQueryFilter = new TLogQueryFilter();
+ struct.logQueryFilter.read(iprot);
+ struct.setLogQueryFilterIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.serverNames != null) {
+ oprot.writeFieldBegin(SERVER_NAMES_FIELD_DESC);
+ {
+ oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRUCT, struct.serverNames.size()));
+ for (TServerName _iter353 : struct.serverNames)
+ {
+ _iter353.write(oprot);
+ }
+ oprot.writeSetEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.logQueryFilter != null) {
+ oprot.writeFieldBegin(LOG_QUERY_FILTER_FIELD_DESC);
+ struct.logQueryFilter.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getSlowLogResponses_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getSlowLogResponses_argsTupleScheme getScheme() {
+ return new getSlowLogResponses_argsTupleScheme();
+ }
+ }
+
+ private static class getSlowLogResponses_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<getSlowLogResponses_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetServerNames()) {
+ optionals.set(0);
+ }
+ if (struct.isSetLogQueryFilter()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetServerNames()) {
+ {
+ oprot.writeI32(struct.serverNames.size());
+ for (TServerName _iter354 : struct.serverNames)
+ {
+ _iter354.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetLogQueryFilter()) {
+ struct.logQueryFilter.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TSet _set355 = iprot.readSetBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.serverNames = new java.util.HashSet<TServerName>(2*_set355.size);
+ @org.apache.thrift.annotation.Nullable TServerName _elem356;
+ for (int _i357 = 0; _i357 < _set355.size; ++_i357)
+ {
+ _elem356 = new TServerName();
+ _elem356.read(iprot);
+ struct.serverNames.add(_elem356);
+ }
+ }
+ struct.setServerNamesIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.logQueryFilter = new TLogQueryFilter();
+ struct.logQueryFilter.read(iprot);
+ struct.setLogQueryFilterIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class getSlowLogResponses_result implements org.apache.thrift.TBase<getSlowLogResponses_result, getSlowLogResponses_result._Fields>, java.io.Serializable, Cloneable, Comparable<getSlowLogResponses_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getSlowLogResponses_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getSlowLogResponses_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getSlowLogResponses_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<TOnlineLogRecord> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TOnlineLogRecord.class))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getSlowLogResponses_result.class, metaDataMap);
+ }
+
+ public getSlowLogResponses_result() {
+ }
+
+ public getSlowLogResponses_result(
+ java.util.List<TOnlineLogRecord> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getSlowLogResponses_result(getSlowLogResponses_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<TOnlineLogRecord> __this__success = new java.util.ArrayList<TOnlineLogRecord>(other.success.size());
+ for (TOnlineLogRecord other_element : other.success) {
+ __this__success.add(new TOnlineLogRecord(other_element));
+ }
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public getSlowLogResponses_result deepCopy() {
+ return new getSlowLogResponses_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TOnlineLogRecord> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TOnlineLogRecord elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<TOnlineLogRecord>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TOnlineLogRecord> getSuccess() {
+ return this.success;
+ }
+
+ public getSlowLogResponses_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<TOnlineLogRecord> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public getSlowLogResponses_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<TOnlineLogRecord>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof getSlowLogResponses_result)
+ return this.equals((getSlowLogResponses_result)that);
+ return false;
+ }
+
+ public boolean equals(getSlowLogResponses_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(getSlowLogResponses_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("getSlowLogResponses_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class getSlowLogResponses_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getSlowLogResponses_resultStandardScheme getScheme() {
+ return new getSlowLogResponses_resultStandardScheme();
+ }
+ }
+
+ private static class getSlowLogResponses_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<getSlowLogResponses_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, getSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list358 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<TOnlineLogRecord>(_list358.size);
+ @org.apache.thrift.annotation.Nullable TOnlineLogRecord _elem359;
+ for (int _i360 = 0; _i360 < _list358.size; ++_i360)
+ {
+ _elem359 = new TOnlineLogRecord();
+ _elem359.read(iprot);
+ struct.success.add(_elem359);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, getSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
+ for (TOnlineLogRecord _iter361 : struct.success)
+ {
+ _iter361.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class getSlowLogResponses_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public getSlowLogResponses_resultTupleScheme getScheme() {
+ return new getSlowLogResponses_resultTupleScheme();
+ }
+ }
+
+ private static class getSlowLogResponses_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<getSlowLogResponses_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, getSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (TOnlineLogRecord _iter362 : struct.success)
+ {
+ _iter362.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, getSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list363 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.success = new java.util.ArrayList<TOnlineLogRecord>(_list363.size);
+ @org.apache.thrift.annotation.Nullable TOnlineLogRecord _elem364;
+ for (int _i365 = 0; _i365 < _list363.size; ++_i365)
+ {
+ _elem364 = new TOnlineLogRecord();
+ _elem364.read(iprot);
+ struct.success.add(_elem364);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class clearSlowLogResponses_args implements org.apache.thrift.TBase<clearSlowLogResponses_args, clearSlowLogResponses_args._Fields>, java.io.Serializable, Cloneable, Comparable<clearSlowLogResponses_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("clearSlowLogResponses_args");
+
+ private static final org.apache.thrift.protocol.TField SERVER_NAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("serverNames", org.apache.thrift.protocol.TType.SET, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new clearSlowLogResponses_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new clearSlowLogResponses_argsTupleSchemeFactory();
+
+ /**
+ * @param serverNames Set of Server names to clean slowlog responses from
+ */
+ public @org.apache.thrift.annotation.Nullable java.util.Set<TServerName> serverNames; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * @param serverNames Set of Server names to clean slowlog responses from
+ */
+ SERVER_NAMES((short)1, "serverNames");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // SERVER_NAMES
+ return SERVER_NAMES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SERVER_NAMES, new org.apache.thrift.meta_data.FieldMetaData("serverNames", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TServerName.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(clearSlowLogResponses_args.class, metaDataMap);
+ }
+
+ public clearSlowLogResponses_args() {
+ }
+
+ public clearSlowLogResponses_args(
+ java.util.Set<TServerName> serverNames)
+ {
+ this();
+ this.serverNames = serverNames;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public clearSlowLogResponses_args(clearSlowLogResponses_args other) {
+ if (other.isSetServerNames()) {
+ java.util.Set<TServerName> __this__serverNames = new java.util.HashSet<TServerName>(other.serverNames.size());
+ for (TServerName other_element : other.serverNames) {
+ __this__serverNames.add(new TServerName(other_element));
+ }
+ this.serverNames = __this__serverNames;
+ }
+ }
+
+ public clearSlowLogResponses_args deepCopy() {
+ return new clearSlowLogResponses_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.serverNames = null;
+ }
+
+ public int getServerNamesSize() {
+ return (this.serverNames == null) ? 0 : this.serverNames.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TServerName> getServerNamesIterator() {
+ return (this.serverNames == null) ? null : this.serverNames.iterator();
+ }
+
+ public void addToServerNames(TServerName elem) {
+ if (this.serverNames == null) {
+ this.serverNames = new java.util.HashSet<TServerName>();
+ }
+ this.serverNames.add(elem);
+ }
+
+ /**
+ * @param serverNames Set of Server names to clean slowlog responses from
+ */
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Set<TServerName> getServerNames() {
+ return this.serverNames;
+ }
+
+ /**
+ * @param serverNames Set of Server names to clean slowlog responses from
+ */
+ public clearSlowLogResponses_args setServerNames(@org.apache.thrift.annotation.Nullable java.util.Set<TServerName> serverNames) {
+ this.serverNames = serverNames;
+ return this;
+ }
+
+ public void unsetServerNames() {
+ this.serverNames = null;
+ }
+
+ /** Returns true if field serverNames is set (has been assigned a value) and false otherwise */
+ public boolean isSetServerNames() {
+ return this.serverNames != null;
+ }
+
+ public void setServerNamesIsSet(boolean value) {
+ if (!value) {
+ this.serverNames = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SERVER_NAMES:
+ if (value == null) {
+ unsetServerNames();
+ } else {
+ setServerNames((java.util.Set<TServerName>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SERVER_NAMES:
+ return getServerNames();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SERVER_NAMES:
+ return isSetServerNames();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof clearSlowLogResponses_args)
+ return this.equals((clearSlowLogResponses_args)that);
+ return false;
+ }
+
+ public boolean equals(clearSlowLogResponses_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_serverNames = true && this.isSetServerNames();
+ boolean that_present_serverNames = true && that.isSetServerNames();
+ if (this_present_serverNames || that_present_serverNames) {
+ if (!(this_present_serverNames && that_present_serverNames))
+ return false;
+ if (!this.serverNames.equals(that.serverNames))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetServerNames()) ? 131071 : 524287);
+ if (isSetServerNames())
+ hashCode = hashCode * 8191 + serverNames.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(clearSlowLogResponses_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetServerNames(), other.isSetServerNames());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetServerNames()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverNames, other.serverNames);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("clearSlowLogResponses_args(");
+ boolean first = true;
+
+ sb.append("serverNames:");
+ if (this.serverNames == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.serverNames);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class clearSlowLogResponses_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public clearSlowLogResponses_argsStandardScheme getScheme() {
+ return new clearSlowLogResponses_argsStandardScheme();
+ }
+ }
+
+ private static class clearSlowLogResponses_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<clearSlowLogResponses_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, clearSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // SERVER_NAMES
+ if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
+ {
+ org.apache.thrift.protocol.TSet _set366 = iprot.readSetBegin();
+ struct.serverNames = new java.util.HashSet<TServerName>(2*_set366.size);
+ @org.apache.thrift.annotation.Nullable TServerName _elem367;
+ for (int _i368 = 0; _i368 < _set366.size; ++_i368)
+ {
+ _elem367 = new TServerName();
+ _elem367.read(iprot);
+ struct.serverNames.add(_elem367);
+ }
+ iprot.readSetEnd();
+ }
+ struct.setServerNamesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, clearSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.serverNames != null) {
+ oprot.writeFieldBegin(SERVER_NAMES_FIELD_DESC);
+ {
+ oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRUCT, struct.serverNames.size()));
+ for (TServerName _iter369 : struct.serverNames)
+ {
+ _iter369.write(oprot);
+ }
+ oprot.writeSetEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class clearSlowLogResponses_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public clearSlowLogResponses_argsTupleScheme getScheme() {
+ return new clearSlowLogResponses_argsTupleScheme();
+ }
+ }
+
+ private static class clearSlowLogResponses_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<clearSlowLogResponses_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, clearSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetServerNames()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetServerNames()) {
+ {
+ oprot.writeI32(struct.serverNames.size());
+ for (TServerName _iter370 : struct.serverNames)
+ {
+ _iter370.write(oprot);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, clearSlowLogResponses_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TSet _set371 = iprot.readSetBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.serverNames = new java.util.HashSet<TServerName>(2*_set371.size);
+ @org.apache.thrift.annotation.Nullable TServerName _elem372;
+ for (int _i373 = 0; _i373 < _set371.size; ++_i373)
+ {
+ _elem372 = new TServerName();
+ _elem372.read(iprot);
+ struct.serverNames.add(_elem372);
+ }
+ }
+ struct.setServerNamesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class clearSlowLogResponses_result implements org.apache.thrift.TBase<clearSlowLogResponses_result, clearSlowLogResponses_result._Fields>, java.io.Serializable, Cloneable, Comparable<clearSlowLogResponses_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("clearSlowLogResponses_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.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new clearSlowLogResponses_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new clearSlowLogResponses_resultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.util.List<java.lang.Boolean> success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(clearSlowLogResponses_result.class, metaDataMap);
+ }
+
+ public clearSlowLogResponses_result() {
+ }
+
+ public clearSlowLogResponses_result(
+ java.util.List<java.lang.Boolean> success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public clearSlowLogResponses_result(clearSlowLogResponses_result other) {
+ if (other.isSetSuccess()) {
+ java.util.List<java.lang.Boolean> __this__success = new java.util.ArrayList<java.lang.Boolean>(other.success);
+ this.success = __this__success;
+ }
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public clearSlowLogResponses_result deepCopy() {
+ return new clearSlowLogResponses_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ this.io = null;
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<java.lang.Boolean> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(boolean elem) {
+ if (this.success == null) {
+ this.success = new java.util.ArrayList<java.lang.Boolean>();
+ }
+ this.success.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<java.lang.Boolean> getSuccess() {
+ return this.success;
+ }
+
+ public clearSlowLogResponses_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List<java.lang.Boolean> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public clearSlowLogResponses_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.util.List<java.lang.Boolean>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof clearSlowLogResponses_result)
+ return this.equals((clearSlowLogResponses_result)that);
+ return false;
+ }
+
+ public boolean equals(clearSlowLogResponses_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(clearSlowLogResponses_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("clearSlowLogResponses_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class clearSlowLogResponses_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public clearSlowLogResponses_resultStandardScheme getScheme() {
+ return new clearSlowLogResponses_resultStandardScheme();
+ }
+ }
+
+ private static class clearSlowLogResponses_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<clearSlowLogResponses_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, clearSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list374 = iprot.readListBegin();
+ struct.success = new java.util.ArrayList<java.lang.Boolean>(_list374.size);
+ boolean _elem375;
+ for (int _i376 = 0; _i376 < _list374.size; ++_i376)
+ {
+ _elem375 = iprot.readBool();
+ struct.success.add(_elem375);
+ }
+ iprot.readListEnd();
+ }
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, clearSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.BOOL, struct.success.size()));
+ for (boolean _iter377 : struct.success)
+ {
+ oprot.writeBool(_iter377);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class clearSlowLogResponses_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public clearSlowLogResponses_resultTupleScheme getScheme() {
+ return new clearSlowLogResponses_resultTupleScheme();
+ }
+ }
+
+ private static class clearSlowLogResponses_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<clearSlowLogResponses_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, clearSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ {
+ oprot.writeI32(struct.success.size());
+ for (boolean _iter378 : struct.success)
+ {
+ oprot.writeBool(_iter378);
+ }
+ }
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, clearSlowLogResponses_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list379 = iprot.readListBegin(org.apache.thrift.protocol.TType.BOOL);
+ struct.success = new java.util.ArrayList<java.lang.Boolean>(_list379.size);
+ boolean _elem380;
+ for (int _i381 = 0; _i381 < _list379.size; ++_i381)
+ {
+ _elem380 = iprot.readBool();
+ struct.success.add(_elem380);
+ }
+ }
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class grant_args implements org.apache.thrift.TBase<grant_args, grant_args._Fields>, java.io.Serializable, Cloneable, Comparable<grant_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("grant_args");
+
+ private static final org.apache.thrift.protocol.TField INFO_FIELD_DESC = new org.apache.thrift.protocol.TField("info", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new grant_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new grant_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TAccessControlEntity info; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ INFO((short)1, "info");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // INFO
+ return INFO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.INFO, new org.apache.thrift.meta_data.FieldMetaData("info", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAccessControlEntity.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(grant_args.class, metaDataMap);
+ }
+
+ public grant_args() {
+ }
+
+ public grant_args(
+ TAccessControlEntity info)
+ {
+ this();
+ this.info = info;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public grant_args(grant_args other) {
+ if (other.isSetInfo()) {
+ this.info = new TAccessControlEntity(other.info);
+ }
+ }
+
+ public grant_args deepCopy() {
+ return new grant_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.info = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TAccessControlEntity getInfo() {
+ return this.info;
+ }
+
+ public grant_args setInfo(@org.apache.thrift.annotation.Nullable TAccessControlEntity info) {
+ this.info = info;
+ return this;
+ }
+
+ public void unsetInfo() {
+ this.info = null;
+ }
+
+ /** Returns true if field info is set (has been assigned a value) and false otherwise */
+ public boolean isSetInfo() {
+ return this.info != null;
+ }
+
+ public void setInfoIsSet(boolean value) {
+ if (!value) {
+ this.info = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case INFO:
+ if (value == null) {
+ unsetInfo();
+ } else {
+ setInfo((TAccessControlEntity)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case INFO:
+ return getInfo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case INFO:
+ return isSetInfo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof grant_args)
+ return this.equals((grant_args)that);
+ return false;
+ }
+
+ public boolean equals(grant_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_info = true && this.isSetInfo();
+ boolean that_present_info = true && that.isSetInfo();
+ if (this_present_info || that_present_info) {
+ if (!(this_present_info && that_present_info))
+ return false;
+ if (!this.info.equals(that.info))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetInfo()) ? 131071 : 524287);
+ if (isSetInfo())
+ hashCode = hashCode * 8191 + info.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(grant_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetInfo(), other.isSetInfo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetInfo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.info, other.info);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("grant_args(");
+ boolean first = true;
+
+ sb.append("info:");
+ if (this.info == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.info);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (info == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'info' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (info != null) {
+ info.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class grant_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_argsStandardScheme getScheme() {
+ return new grant_argsStandardScheme();
+ }
+ }
+
+ private static class grant_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<grant_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, grant_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // INFO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, grant_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.info != null) {
+ oprot.writeFieldBegin(INFO_FIELD_DESC);
+ struct.info.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class grant_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_argsTupleScheme getScheme() {
+ return new grant_argsTupleScheme();
+ }
+ }
+
+ private static class grant_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<grant_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, grant_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, grant_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class grant_result implements org.apache.thrift.TBase<grant_result, grant_result._Fields>, java.io.Serializable, Cloneable, Comparable<grant_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("grant_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new grant_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new grant_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(grant_result.class, metaDataMap);
+ }
+
+ public grant_result() {
+ }
+
+ public grant_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public grant_result(grant_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public grant_result deepCopy() {
+ return new grant_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public grant_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public grant_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof grant_result)
+ return this.equals((grant_result)that);
+ return false;
+ }
+
+ public boolean equals(grant_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(grant_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("grant_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class grant_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_resultStandardScheme getScheme() {
+ return new grant_resultStandardScheme();
+ }
+ }
+
+ private static class grant_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<grant_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, grant_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, grant_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class grant_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public grant_resultTupleScheme getScheme() {
+ return new grant_resultTupleScheme();
+ }
+ }
+
+ private static class grant_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<grant_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, grant_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, grant_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class revoke_args implements org.apache.thrift.TBase<revoke_args, revoke_args._Fields>, java.io.Serializable, Cloneable, Comparable<revoke_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("revoke_args");
+
+ private static final org.apache.thrift.protocol.TField INFO_FIELD_DESC = new org.apache.thrift.protocol.TField("info", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new revoke_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new revoke_argsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TAccessControlEntity info; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ INFO((short)1, "info");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // INFO
+ return INFO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.INFO, new org.apache.thrift.meta_data.FieldMetaData("info", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAccessControlEntity.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(revoke_args.class, metaDataMap);
+ }
+
+ public revoke_args() {
+ }
+
+ public revoke_args(
+ TAccessControlEntity info)
+ {
+ this();
+ this.info = info;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public revoke_args(revoke_args other) {
+ if (other.isSetInfo()) {
+ this.info = new TAccessControlEntity(other.info);
+ }
+ }
+
+ public revoke_args deepCopy() {
+ return new revoke_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.info = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TAccessControlEntity getInfo() {
+ return this.info;
+ }
+
+ public revoke_args setInfo(@org.apache.thrift.annotation.Nullable TAccessControlEntity info) {
+ this.info = info;
+ return this;
+ }
+
+ public void unsetInfo() {
+ this.info = null;
+ }
+
+ /** Returns true if field info is set (has been assigned a value) and false otherwise */
+ public boolean isSetInfo() {
+ return this.info != null;
+ }
+
+ public void setInfoIsSet(boolean value) {
+ if (!value) {
+ this.info = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case INFO:
+ if (value == null) {
+ unsetInfo();
+ } else {
+ setInfo((TAccessControlEntity)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case INFO:
+ return getInfo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case INFO:
+ return isSetInfo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof revoke_args)
+ return this.equals((revoke_args)that);
+ return false;
+ }
+
+ public boolean equals(revoke_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_info = true && this.isSetInfo();
+ boolean that_present_info = true && that.isSetInfo();
+ if (this_present_info || that_present_info) {
+ if (!(this_present_info && that_present_info))
+ return false;
+ if (!this.info.equals(that.info))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetInfo()) ? 131071 : 524287);
+ if (isSetInfo())
+ hashCode = hashCode * 8191 + info.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(revoke_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetInfo(), other.isSetInfo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetInfo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.info, other.info);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("revoke_args(");
+ boolean first = true;
+
+ sb.append("info:");
+ if (this.info == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.info);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (info == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'info' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (info != null) {
+ info.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class revoke_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_argsStandardScheme getScheme() {
+ return new revoke_argsStandardScheme();
+ }
+ }
+
+ private static class revoke_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<revoke_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, revoke_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // INFO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, revoke_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.info != null) {
+ oprot.writeFieldBegin(INFO_FIELD_DESC);
+ struct.info.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class revoke_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_argsTupleScheme getScheme() {
+ return new revoke_argsTupleScheme();
+ }
+ }
+
+ private static class revoke_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<revoke_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, revoke_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, revoke_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.info = new TAccessControlEntity();
+ struct.info.read(iprot);
+ struct.setInfoIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ public static class revoke_result implements org.apache.thrift.TBase<revoke_result, revoke_result._Fields>, java.io.Serializable, Cloneable, Comparable<revoke_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("revoke_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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new revoke_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new revoke_resultTupleSchemeFactory();
+
+ public boolean success; // required
+ public @org.apache.thrift.annotation.Nullable TIOError io; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ case 1: // IO
+ return IO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __SUCCESS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(revoke_result.class, metaDataMap);
+ }
+
+ public revoke_result() {
+ }
+
+ public revoke_result(
+ boolean success,
+ TIOError io)
+ {
+ this();
+ this.success = success;
+ setSuccessIsSet(true);
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public revoke_result(revoke_result other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.success = other.success;
+ if (other.isSetIo()) {
+ this.io = new TIOError(other.io);
+ }
+ }
+
+ public revoke_result deepCopy() {
+ return new revoke_result(this);
+ }
+
+ @Override
+ public void clear() {
+ setSuccessIsSet(false);
+ this.success = false;
+ this.io = null;
+ }
+
+ public boolean isSuccess() {
+ return this.success;
+ }
+
+ public revoke_result setSuccess(boolean success) {
+ this.success = success;
+ setSuccessIsSet(true);
+ return this;
+ }
+
+ public void unsetSuccess() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TIOError getIo() {
+ return this.io;
+ }
+
+ public revoke_result setIo(@org.apache.thrift.annotation.Nullable TIOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been assigned a value) and false otherwise */
+ public boolean isSetIo() {
+ return this.io != null;
+ }
+
+ public void setIoIsSet(boolean value) {
+ if (!value) {
+ this.io = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((java.lang.Boolean)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((TIOError)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof revoke_result)
+ return this.equals((revoke_result)that);
+ return false;
+ }
+
+ public boolean equals(revoke_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true;
+ boolean that_present_success = true;
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (this.success != that.success)
+ return false;
+ }
+
+ boolean this_present_io = true && this.isSetIo();
+ boolean that_present_io = true && that.isSetIo();
+ if (this_present_io || that_present_io) {
+ if (!(this_present_io && that_present_io))
+ return false;
+ if (!this.io.equals(that.io))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((success) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetIo()) ? 131071 : 524287);
+ if (isSetIo())
+ hashCode = hashCode * 8191 + io.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(revoke_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetIo(), other.isSetIo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetIo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, other.io);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("revoke_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ sb.append(this.success);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("io:");
+ if (this.io == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.io);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class revoke_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_resultStandardScheme getScheme() {
+ return new revoke_resultStandardScheme();
+ }
+ }
+
+ private static class revoke_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<revoke_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, revoke_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 1: // IO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, revoke_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ oprot.writeBool(struct.success);
+ oprot.writeFieldEnd();
+ }
+ if (struct.io != null) {
+ oprot.writeFieldBegin(IO_FIELD_DESC);
+ struct.io.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class revoke_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public revoke_resultTupleScheme getScheme() {
+ return new revoke_resultTupleScheme();
+ }
+ }
+
+ private static class revoke_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<revoke_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, revoke_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ if (struct.isSetIo()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetSuccess()) {
+ oprot.writeBool(struct.success);
+ }
+ if (struct.isSetIo()) {
+ struct.io.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, revoke_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.success = iprot.readBool();
+ struct.setSuccessIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.io = new TIOError();
+ struct.io.read(iprot);
+ struct.setIoIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionInfo.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionInfo.java
new file mode 100644
index 0000000..b4ad2b9
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionInfo.java
@@ -0,0 +1,1019 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class THRegionInfo implements org.apache.thrift.TBase<THRegionInfo, THRegionInfo._Fields>, java.io.Serializable, Cloneable, Comparable<THRegionInfo> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("THRegionInfo");
+
+ private static final org.apache.thrift.protocol.TField REGION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("regionId", org.apache.thrift.protocol.TType.I64, (short)1);
+ 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)2);
+ private static final org.apache.thrift.protocol.TField START_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("startKey", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField END_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("endKey", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField OFFLINE_FIELD_DESC = new org.apache.thrift.protocol.TField("offline", org.apache.thrift.protocol.TType.BOOL, (short)5);
+ private static final org.apache.thrift.protocol.TField SPLIT_FIELD_DESC = new org.apache.thrift.protocol.TField("split", org.apache.thrift.protocol.TType.BOOL, (short)6);
+ private static final org.apache.thrift.protocol.TField REPLICA_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("replicaId", org.apache.thrift.protocol.TType.I32, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new THRegionInfoStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new THRegionInfoTupleSchemeFactory();
+
+ public long regionId; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName; // required
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startKey; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer endKey; // optional
+ public boolean offline; // optional
+ public boolean split; // optional
+ public int replicaId; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REGION_ID((short)1, "regionId"),
+ TABLE_NAME((short)2, "tableName"),
+ START_KEY((short)3, "startKey"),
+ END_KEY((short)4, "endKey"),
+ OFFLINE((short)5, "offline"),
+ SPLIT((short)6, "split"),
+ REPLICA_ID((short)7, "replicaId");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // REGION_ID
+ return REGION_ID;
+ case 2: // TABLE_NAME
+ return TABLE_NAME;
+ case 3: // START_KEY
+ return START_KEY;
+ case 4: // END_KEY
+ return END_KEY;
+ case 5: // OFFLINE
+ return OFFLINE;
+ case 6: // SPLIT
+ return SPLIT;
+ case 7: // REPLICA_ID
+ return REPLICA_ID;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __REGIONID_ISSET_ID = 0;
+ private static final int __OFFLINE_ISSET_ID = 1;
+ private static final int __SPLIT_ISSET_ID = 2;
+ private static final int __REPLICAID_ISSET_ID = 3;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.START_KEY,_Fields.END_KEY,_Fields.OFFLINE,_Fields.SPLIT,_Fields.REPLICA_ID};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.REGION_ID, new org.apache.thrift.meta_data.FieldMetaData("regionId", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.START_KEY, new org.apache.thrift.meta_data.FieldMetaData("startKey", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.END_KEY, new org.apache.thrift.meta_data.FieldMetaData("endKey", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.OFFLINE, new org.apache.thrift.meta_data.FieldMetaData("offline", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.SPLIT, new org.apache.thrift.meta_data.FieldMetaData("split", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.REPLICA_ID, new org.apache.thrift.meta_data.FieldMetaData("replicaId", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(THRegionInfo.class, metaDataMap);
+ }
+
+ public THRegionInfo() {
+ }
+
+ public THRegionInfo(
+ long regionId,
+ java.nio.ByteBuffer tableName)
+ {
+ this();
+ this.regionId = regionId;
+ setRegionIdIsSet(true);
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public THRegionInfo(THRegionInfo other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.regionId = other.regionId;
+ if (other.isSetTableName()) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(other.tableName);
+ }
+ if (other.isSetStartKey()) {
+ this.startKey = org.apache.thrift.TBaseHelper.copyBinary(other.startKey);
+ }
+ if (other.isSetEndKey()) {
+ this.endKey = org.apache.thrift.TBaseHelper.copyBinary(other.endKey);
+ }
+ this.offline = other.offline;
+ this.split = other.split;
+ this.replicaId = other.replicaId;
+ }
+
+ public THRegionInfo deepCopy() {
+ return new THRegionInfo(this);
+ }
+
+ @Override
+ public void clear() {
+ setRegionIdIsSet(false);
+ this.regionId = 0;
+ this.tableName = null;
+ this.startKey = null;
+ this.endKey = null;
+ setOfflineIsSet(false);
+ this.offline = false;
+ setSplitIsSet(false);
+ this.split = false;
+ setReplicaIdIsSet(false);
+ this.replicaId = 0;
+ }
+
+ public long getRegionId() {
+ return this.regionId;
+ }
+
+ public THRegionInfo setRegionId(long regionId) {
+ this.regionId = regionId;
+ setRegionIdIsSet(true);
+ return this;
+ }
+
+ public void unsetRegionId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __REGIONID_ISSET_ID);
+ }
+
+ /** Returns true if field regionId is set (has been assigned a value) and false otherwise */
+ public boolean isSetRegionId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __REGIONID_ISSET_ID);
+ }
+
+ public void setRegionIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __REGIONID_ISSET_ID, value);
+ }
+
+ public byte[] getTableName() {
+ setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName));
+ return tableName == null ? null : tableName.array();
+ }
+
+ public java.nio.ByteBuffer bufferForTableName() {
+ return org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ }
+
+ public THRegionInfo setTableName(byte[] tableName) {
+ this.tableName = tableName == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(tableName.clone());
+ return this;
+ }
+
+ public THRegionInfo setTableName(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer tableName) {
+ this.tableName = org.apache.thrift.TBaseHelper.copyBinary(tableName);
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public byte[] getStartKey() {
+ setStartKey(org.apache.thrift.TBaseHelper.rightSize(startKey));
+ return startKey == null ? null : startKey.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStartKey() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startKey);
+ }
+
+ public THRegionInfo setStartKey(byte[] startKey) {
+ this.startKey = startKey == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startKey.clone());
+ return this;
+ }
+
+ public THRegionInfo setStartKey(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startKey) {
+ this.startKey = org.apache.thrift.TBaseHelper.copyBinary(startKey);
+ return this;
+ }
+
+ public void unsetStartKey() {
+ this.startKey = null;
+ }
+
+ /** Returns true if field startKey is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartKey() {
+ return this.startKey != null;
+ }
+
+ public void setStartKeyIsSet(boolean value) {
+ if (!value) {
+ this.startKey = null;
+ }
+ }
+
+ public byte[] getEndKey() {
+ setEndKey(org.apache.thrift.TBaseHelper.rightSize(endKey));
+ return endKey == null ? null : endKey.array();
+ }
+
+ public java.nio.ByteBuffer bufferForEndKey() {
+ return org.apache.thrift.TBaseHelper.copyBinary(endKey);
+ }
+
+ public THRegionInfo setEndKey(byte[] endKey) {
+ this.endKey = endKey == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(endKey.clone());
+ return this;
+ }
+
+ public THRegionInfo setEndKey(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer endKey) {
+ this.endKey = org.apache.thrift.TBaseHelper.copyBinary(endKey);
+ return this;
+ }
+
+ public void unsetEndKey() {
+ this.endKey = null;
+ }
+
+ /** Returns true if field endKey is set (has been assigned a value) and false otherwise */
+ public boolean isSetEndKey() {
+ return this.endKey != null;
+ }
+
+ public void setEndKeyIsSet(boolean value) {
+ if (!value) {
+ this.endKey = null;
+ }
+ }
+
+ public boolean isOffline() {
+ return this.offline;
+ }
+
+ public THRegionInfo setOffline(boolean offline) {
+ this.offline = offline;
+ setOfflineIsSet(true);
+ return this;
+ }
+
+ public void unsetOffline() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __OFFLINE_ISSET_ID);
+ }
+
+ /** Returns true if field offline is set (has been assigned a value) and false otherwise */
+ public boolean isSetOffline() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __OFFLINE_ISSET_ID);
+ }
+
+ public void setOfflineIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __OFFLINE_ISSET_ID, value);
+ }
+
+ public boolean isSplit() {
+ return this.split;
+ }
+
+ public THRegionInfo setSplit(boolean split) {
+ this.split = split;
+ setSplitIsSet(true);
+ return this;
+ }
+
+ public void unsetSplit() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __SPLIT_ISSET_ID);
+ }
+
+ /** Returns true if field split is set (has been assigned a value) and false otherwise */
+ public boolean isSetSplit() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __SPLIT_ISSET_ID);
+ }
+
+ public void setSplitIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __SPLIT_ISSET_ID, value);
+ }
+
+ public int getReplicaId() {
+ return this.replicaId;
+ }
+
+ public THRegionInfo setReplicaId(int replicaId) {
+ this.replicaId = replicaId;
+ setReplicaIdIsSet(true);
+ return this;
+ }
+
+ public void unsetReplicaId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __REPLICAID_ISSET_ID);
+ }
+
+ /** Returns true if field replicaId is set (has been assigned a value) and false otherwise */
+ public boolean isSetReplicaId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __REPLICAID_ISSET_ID);
+ }
+
+ public void setReplicaIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __REPLICAID_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case REGION_ID:
+ if (value == null) {
+ unsetRegionId();
+ } else {
+ setRegionId((java.lang.Long)value);
+ }
+ break;
+
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ if (value instanceof byte[]) {
+ setTableName((byte[])value);
+ } else {
+ setTableName((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case START_KEY:
+ if (value == null) {
+ unsetStartKey();
+ } else {
+ if (value instanceof byte[]) {
+ setStartKey((byte[])value);
+ } else {
+ setStartKey((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case END_KEY:
+ if (value == null) {
+ unsetEndKey();
+ } else {
+ if (value instanceof byte[]) {
+ setEndKey((byte[])value);
+ } else {
+ setEndKey((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case OFFLINE:
+ if (value == null) {
+ unsetOffline();
+ } else {
+ setOffline((java.lang.Boolean)value);
+ }
+ break;
+
+ case SPLIT:
+ if (value == null) {
+ unsetSplit();
+ } else {
+ setSplit((java.lang.Boolean)value);
+ }
+ break;
+
+ case REPLICA_ID:
+ if (value == null) {
+ unsetReplicaId();
+ } else {
+ setReplicaId((java.lang.Integer)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REGION_ID:
+ return getRegionId();
+
+ case TABLE_NAME:
+ return getTableName();
+
+ case START_KEY:
+ return getStartKey();
+
+ case END_KEY:
+ return getEndKey();
+
+ case OFFLINE:
+ return isOffline();
+
+ case SPLIT:
+ return isSplit();
+
+ case REPLICA_ID:
+ return getReplicaId();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case REGION_ID:
+ return isSetRegionId();
+ case TABLE_NAME:
+ return isSetTableName();
+ case START_KEY:
+ return isSetStartKey();
+ case END_KEY:
+ return isSetEndKey();
+ case OFFLINE:
+ return isSetOffline();
+ case SPLIT:
+ return isSetSplit();
+ case REPLICA_ID:
+ return isSetReplicaId();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof THRegionInfo)
+ return this.equals((THRegionInfo)that);
+ return false;
+ }
+
+ public boolean equals(THRegionInfo that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_regionId = true;
+ boolean that_present_regionId = true;
+ if (this_present_regionId || that_present_regionId) {
+ if (!(this_present_regionId && that_present_regionId))
+ return false;
+ if (this.regionId != that.regionId)
+ return false;
+ }
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_startKey = true && this.isSetStartKey();
+ boolean that_present_startKey = true && that.isSetStartKey();
+ if (this_present_startKey || that_present_startKey) {
+ if (!(this_present_startKey && that_present_startKey))
+ return false;
+ if (!this.startKey.equals(that.startKey))
+ return false;
+ }
+
+ boolean this_present_endKey = true && this.isSetEndKey();
+ boolean that_present_endKey = true && that.isSetEndKey();
+ if (this_present_endKey || that_present_endKey) {
+ if (!(this_present_endKey && that_present_endKey))
+ return false;
+ if (!this.endKey.equals(that.endKey))
+ return false;
+ }
+
+ boolean this_present_offline = true && this.isSetOffline();
+ boolean that_present_offline = true && that.isSetOffline();
+ if (this_present_offline || that_present_offline) {
+ if (!(this_present_offline && that_present_offline))
+ return false;
+ if (this.offline != that.offline)
+ return false;
+ }
+
+ boolean this_present_split = true && this.isSetSplit();
+ boolean that_present_split = true && that.isSetSplit();
+ if (this_present_split || that_present_split) {
+ if (!(this_present_split && that_present_split))
+ return false;
+ if (this.split != that.split)
+ return false;
+ }
+
+ boolean this_present_replicaId = true && this.isSetReplicaId();
+ boolean that_present_replicaId = true && that.isSetReplicaId();
+ if (this_present_replicaId || that_present_replicaId) {
+ if (!(this_present_replicaId && that_present_replicaId))
+ return false;
+ if (this.replicaId != that.replicaId)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(regionId);
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStartKey()) ? 131071 : 524287);
+ if (isSetStartKey())
+ hashCode = hashCode * 8191 + startKey.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetEndKey()) ? 131071 : 524287);
+ if (isSetEndKey())
+ hashCode = hashCode * 8191 + endKey.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetOffline()) ? 131071 : 524287);
+ if (isSetOffline())
+ hashCode = hashCode * 8191 + ((offline) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetSplit()) ? 131071 : 524287);
+ if (isSetSplit())
+ hashCode = hashCode * 8191 + ((split) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetReplicaId()) ? 131071 : 524287);
+ if (isSetReplicaId())
+ hashCode = hashCode * 8191 + replicaId;
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(THRegionInfo other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRegionId(), other.isSetRegionId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRegionId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.regionId, other.regionId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStartKey(), other.isSetStartKey());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartKey()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startKey, other.startKey);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetEndKey(), other.isSetEndKey());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetEndKey()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.endKey, other.endKey);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetOffline(), other.isSetOffline());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetOffline()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offline, other.offline);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetSplit(), other.isSetSplit());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSplit()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.split, other.split);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetReplicaId(), other.isSetReplicaId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReplicaId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.replicaId, other.replicaId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("THRegionInfo(");
+ boolean first = true;
+
+ sb.append("regionId:");
+ sb.append(this.regionId);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.tableName, sb);
+ }
+ first = false;
+ if (isSetStartKey()) {
+ if (!first) sb.append(", ");
+ sb.append("startKey:");
+ if (this.startKey == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startKey, sb);
+ }
+ first = false;
+ }
+ if (isSetEndKey()) {
+ if (!first) sb.append(", ");
+ sb.append("endKey:");
+ if (this.endKey == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.endKey, sb);
+ }
+ first = false;
+ }
+ if (isSetOffline()) {
+ if (!first) sb.append(", ");
+ sb.append("offline:");
+ sb.append(this.offline);
+ first = false;
+ }
+ if (isSetSplit()) {
+ if (!first) sb.append(", ");
+ sb.append("split:");
+ sb.append(this.split);
+ first = false;
+ }
+ if (isSetReplicaId()) {
+ if (!first) sb.append(", ");
+ sb.append("replicaId:");
+ sb.append(this.replicaId);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // alas, we cannot check 'regionId' because it's a primitive and you chose the non-beans generator.
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class THRegionInfoStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public THRegionInfoStandardScheme getScheme() {
+ return new THRegionInfoStandardScheme();
+ }
+ }
+
+ private static class THRegionInfoStandardScheme extends org.apache.thrift.scheme.StandardScheme<THRegionInfo> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, THRegionInfo struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // REGION_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.regionId = iprot.readI64();
+ struct.setRegionIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // START_KEY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startKey = iprot.readBinary();
+ struct.setStartKeyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // END_KEY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.endKey = iprot.readBinary();
+ struct.setEndKeyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // OFFLINE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.offline = iprot.readBool();
+ struct.setOfflineIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // SPLIT
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.split = iprot.readBool();
+ struct.setSplitIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // REPLICA_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.replicaId = iprot.readI32();
+ struct.setReplicaIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetRegionId()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'regionId' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, THRegionInfo struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(REGION_ID_FIELD_DESC);
+ oprot.writeI64(struct.regionId);
+ oprot.writeFieldEnd();
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.startKey != null) {
+ if (struct.isSetStartKey()) {
+ oprot.writeFieldBegin(START_KEY_FIELD_DESC);
+ oprot.writeBinary(struct.startKey);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.endKey != null) {
+ if (struct.isSetEndKey()) {
+ oprot.writeFieldBegin(END_KEY_FIELD_DESC);
+ oprot.writeBinary(struct.endKey);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetOffline()) {
+ oprot.writeFieldBegin(OFFLINE_FIELD_DESC);
+ oprot.writeBool(struct.offline);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetSplit()) {
+ oprot.writeFieldBegin(SPLIT_FIELD_DESC);
+ oprot.writeBool(struct.split);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetReplicaId()) {
+ oprot.writeFieldBegin(REPLICA_ID_FIELD_DESC);
+ oprot.writeI32(struct.replicaId);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class THRegionInfoTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public THRegionInfoTupleScheme getScheme() {
+ return new THRegionInfoTupleScheme();
+ }
+ }
+
+ private static class THRegionInfoTupleScheme extends org.apache.thrift.scheme.TupleScheme<THRegionInfo> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, THRegionInfo struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeI64(struct.regionId);
+ oprot.writeBinary(struct.tableName);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetStartKey()) {
+ optionals.set(0);
+ }
+ if (struct.isSetEndKey()) {
+ optionals.set(1);
+ }
+ if (struct.isSetOffline()) {
+ optionals.set(2);
+ }
+ if (struct.isSetSplit()) {
+ optionals.set(3);
+ }
+ if (struct.isSetReplicaId()) {
+ optionals.set(4);
+ }
+ oprot.writeBitSet(optionals, 5);
+ if (struct.isSetStartKey()) {
+ oprot.writeBinary(struct.startKey);
+ }
+ if (struct.isSetEndKey()) {
+ oprot.writeBinary(struct.endKey);
+ }
+ if (struct.isSetOffline()) {
+ oprot.writeBool(struct.offline);
+ }
+ if (struct.isSetSplit()) {
+ oprot.writeBool(struct.split);
+ }
+ if (struct.isSetReplicaId()) {
+ oprot.writeI32(struct.replicaId);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, THRegionInfo struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.regionId = iprot.readI64();
+ struct.setRegionIdIsSet(true);
+ struct.tableName = iprot.readBinary();
+ struct.setTableNameIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(5);
+ if (incoming.get(0)) {
+ struct.startKey = iprot.readBinary();
+ struct.setStartKeyIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.endKey = iprot.readBinary();
+ struct.setEndKeyIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.offline = iprot.readBool();
+ struct.setOfflineIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.split = iprot.readBool();
+ struct.setSplitIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.replicaId = iprot.readI32();
+ struct.setReplicaIdIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionLocation.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionLocation.java
new file mode 100644
index 0000000..8c9f2ba
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionLocation.java
@@ -0,0 +1,479 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class THRegionLocation implements org.apache.thrift.TBase<THRegionLocation, THRegionLocation._Fields>, java.io.Serializable, Cloneable, Comparable<THRegionLocation> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("THRegionLocation");
+
+ private static final org.apache.thrift.protocol.TField SERVER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("serverName", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField REGION_INFO_FIELD_DESC = new org.apache.thrift.protocol.TField("regionInfo", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new THRegionLocationStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new THRegionLocationTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TServerName serverName; // required
+ public @org.apache.thrift.annotation.Nullable THRegionInfo regionInfo; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SERVER_NAME((short)1, "serverName"),
+ REGION_INFO((short)2, "regionInfo");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // SERVER_NAME
+ return SERVER_NAME;
+ case 2: // REGION_INFO
+ return REGION_INFO;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SERVER_NAME, new org.apache.thrift.meta_data.FieldMetaData("serverName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TServerName.class)));
+ tmpMap.put(_Fields.REGION_INFO, new org.apache.thrift.meta_data.FieldMetaData("regionInfo", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, THRegionInfo.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(THRegionLocation.class, metaDataMap);
+ }
+
+ public THRegionLocation() {
+ }
+
+ public THRegionLocation(
+ TServerName serverName,
+ THRegionInfo regionInfo)
+ {
+ this();
+ this.serverName = serverName;
+ this.regionInfo = regionInfo;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public THRegionLocation(THRegionLocation other) {
+ if (other.isSetServerName()) {
+ this.serverName = new TServerName(other.serverName);
+ }
+ if (other.isSetRegionInfo()) {
+ this.regionInfo = new THRegionInfo(other.regionInfo);
+ }
+ }
+
+ public THRegionLocation deepCopy() {
+ return new THRegionLocation(this);
+ }
+
+ @Override
+ public void clear() {
+ this.serverName = null;
+ this.regionInfo = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TServerName getServerName() {
+ return this.serverName;
+ }
+
+ public THRegionLocation setServerName(@org.apache.thrift.annotation.Nullable TServerName serverName) {
+ this.serverName = serverName;
+ return this;
+ }
+
+ public void unsetServerName() {
+ this.serverName = null;
+ }
+
+ /** Returns true if field serverName is set (has been assigned a value) and false otherwise */
+ public boolean isSetServerName() {
+ return this.serverName != null;
+ }
+
+ public void setServerNameIsSet(boolean value) {
+ if (!value) {
+ this.serverName = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public THRegionInfo getRegionInfo() {
+ return this.regionInfo;
+ }
+
+ public THRegionLocation setRegionInfo(@org.apache.thrift.annotation.Nullable THRegionInfo regionInfo) {
+ this.regionInfo = regionInfo;
+ return this;
+ }
+
+ public void unsetRegionInfo() {
+ this.regionInfo = null;
+ }
+
+ /** Returns true if field regionInfo is set (has been assigned a value) and false otherwise */
+ public boolean isSetRegionInfo() {
+ return this.regionInfo != null;
+ }
+
+ public void setRegionInfoIsSet(boolean value) {
+ if (!value) {
+ this.regionInfo = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SERVER_NAME:
+ if (value == null) {
+ unsetServerName();
+ } else {
+ setServerName((TServerName)value);
+ }
+ break;
+
+ case REGION_INFO:
+ if (value == null) {
+ unsetRegionInfo();
+ } else {
+ setRegionInfo((THRegionInfo)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SERVER_NAME:
+ return getServerName();
+
+ case REGION_INFO:
+ return getRegionInfo();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SERVER_NAME:
+ return isSetServerName();
+ case REGION_INFO:
+ return isSetRegionInfo();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof THRegionLocation)
+ return this.equals((THRegionLocation)that);
+ return false;
+ }
+
+ public boolean equals(THRegionLocation that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_serverName = true && this.isSetServerName();
+ boolean that_present_serverName = true && that.isSetServerName();
+ if (this_present_serverName || that_present_serverName) {
+ if (!(this_present_serverName && that_present_serverName))
+ return false;
+ if (!this.serverName.equals(that.serverName))
+ return false;
+ }
+
+ boolean this_present_regionInfo = true && this.isSetRegionInfo();
+ boolean that_present_regionInfo = true && that.isSetRegionInfo();
+ if (this_present_regionInfo || that_present_regionInfo) {
+ if (!(this_present_regionInfo && that_present_regionInfo))
+ return false;
+ if (!this.regionInfo.equals(that.regionInfo))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetServerName()) ? 131071 : 524287);
+ if (isSetServerName())
+ hashCode = hashCode * 8191 + serverName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetRegionInfo()) ? 131071 : 524287);
+ if (isSetRegionInfo())
+ hashCode = hashCode * 8191 + regionInfo.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(THRegionLocation other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetServerName(), other.isSetServerName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetServerName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverName, other.serverName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRegionInfo(), other.isSetRegionInfo());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRegionInfo()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.regionInfo, other.regionInfo);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("THRegionLocation(");
+ boolean first = true;
+
+ sb.append("serverName:");
+ if (this.serverName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.serverName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("regionInfo:");
+ if (this.regionInfo == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.regionInfo);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (serverName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'serverName' was not present! Struct: " + toString());
+ }
+ if (regionInfo == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'regionInfo' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (serverName != null) {
+ serverName.validate();
+ }
+ if (regionInfo != null) {
+ regionInfo.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class THRegionLocationStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public THRegionLocationStandardScheme getScheme() {
+ return new THRegionLocationStandardScheme();
+ }
+ }
+
+ private static class THRegionLocationStandardScheme extends org.apache.thrift.scheme.StandardScheme<THRegionLocation> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, THRegionLocation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // SERVER_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.serverName = new TServerName();
+ struct.serverName.read(iprot);
+ struct.setServerNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // REGION_INFO
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.regionInfo = new THRegionInfo();
+ struct.regionInfo.read(iprot);
+ struct.setRegionInfoIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, THRegionLocation struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.serverName != null) {
+ oprot.writeFieldBegin(SERVER_NAME_FIELD_DESC);
+ struct.serverName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.regionInfo != null) {
+ oprot.writeFieldBegin(REGION_INFO_FIELD_DESC);
+ struct.regionInfo.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class THRegionLocationTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public THRegionLocationTupleScheme getScheme() {
+ return new THRegionLocationTupleScheme();
+ }
+ }
+
+ private static class THRegionLocationTupleScheme extends org.apache.thrift.scheme.TupleScheme<THRegionLocation> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, THRegionLocation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.serverName.write(oprot);
+ struct.regionInfo.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, THRegionLocation struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.serverName = new TServerName();
+ struct.serverName.read(iprot);
+ struct.setServerNameIsSet(true);
+ struct.regionInfo = new THRegionInfo();
+ struct.regionInfo.read(iprot);
+ struct.setRegionInfoIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIOError.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIOError.java
new file mode 100644
index 0000000..86f8077
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIOError.java
@@ -0,0 +1,481 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * A TIOError exception signals that an error occurred communicating
+ * to the HBase master or a HBase region server. Also used to return
+ * more general HBase error conditions.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TIOError extends org.apache.thrift.TException implements org.apache.thrift.TBase<TIOError, TIOError._Fields>, java.io.Serializable, Cloneable, Comparable<TIOError> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIOError");
+
+ private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField CAN_RETRY_FIELD_DESC = new org.apache.thrift.protocol.TField("canRetry", org.apache.thrift.protocol.TType.BOOL, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TIOErrorStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TIOErrorTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String message; // optional
+ public boolean canRetry; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ MESSAGE((short)1, "message"),
+ CAN_RETRY((short)2, "canRetry");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // MESSAGE
+ return MESSAGE;
+ case 2: // CAN_RETRY
+ return CAN_RETRY;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __CANRETRY_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.MESSAGE,_Fields.CAN_RETRY};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.CAN_RETRY, new org.apache.thrift.meta_data.FieldMetaData("canRetry", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TIOError.class, metaDataMap);
+ }
+
+ public TIOError() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TIOError(TIOError other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetMessage()) {
+ this.message = other.message;
+ }
+ this.canRetry = other.canRetry;
+ }
+
+ public TIOError deepCopy() {
+ return new TIOError(this);
+ }
+
+ @Override
+ public void clear() {
+ this.message = null;
+ setCanRetryIsSet(false);
+ this.canRetry = false;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getMessage() {
+ return this.message;
+ }
+
+ public TIOError setMessage(@org.apache.thrift.annotation.Nullable java.lang.String message) {
+ this.message = message;
+ return this;
+ }
+
+ public void unsetMessage() {
+ this.message = null;
+ }
+
+ /** Returns true if field message is set (has been assigned a value) and false otherwise */
+ public boolean isSetMessage() {
+ return this.message != null;
+ }
+
+ public void setMessageIsSet(boolean value) {
+ if (!value) {
+ this.message = null;
+ }
+ }
+
+ public boolean isCanRetry() {
+ return this.canRetry;
+ }
+
+ public TIOError setCanRetry(boolean canRetry) {
+ this.canRetry = canRetry;
+ setCanRetryIsSet(true);
+ return this;
+ }
+
+ public void unsetCanRetry() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CANRETRY_ISSET_ID);
+ }
+
+ /** Returns true if field canRetry is set (has been assigned a value) and false otherwise */
+ public boolean isSetCanRetry() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CANRETRY_ISSET_ID);
+ }
+
+ public void setCanRetryIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CANRETRY_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case MESSAGE:
+ if (value == null) {
+ unsetMessage();
+ } else {
+ setMessage((java.lang.String)value);
+ }
+ break;
+
+ case CAN_RETRY:
+ if (value == null) {
+ unsetCanRetry();
+ } else {
+ setCanRetry((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MESSAGE:
+ return getMessage();
+
+ case CAN_RETRY:
+ return isCanRetry();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case MESSAGE:
+ return isSetMessage();
+ case CAN_RETRY:
+ return isSetCanRetry();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TIOError)
+ return this.equals((TIOError)that);
+ return false;
+ }
+
+ public boolean equals(TIOError that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_message = true && this.isSetMessage();
+ boolean that_present_message = true && that.isSetMessage();
+ if (this_present_message || that_present_message) {
+ if (!(this_present_message && that_present_message))
+ return false;
+ if (!this.message.equals(that.message))
+ return false;
+ }
+
+ boolean this_present_canRetry = true && this.isSetCanRetry();
+ boolean that_present_canRetry = true && that.isSetCanRetry();
+ if (this_present_canRetry || that_present_canRetry) {
+ if (!(this_present_canRetry && that_present_canRetry))
+ return false;
+ if (this.canRetry != that.canRetry)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetMessage()) ? 131071 : 524287);
+ if (isSetMessage())
+ hashCode = hashCode * 8191 + message.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetCanRetry()) ? 131071 : 524287);
+ if (isSetCanRetry())
+ hashCode = hashCode * 8191 + ((canRetry) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TIOError other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetMessage(), other.isSetMessage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMessage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.message, other.message);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCanRetry(), other.isSetCanRetry());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCanRetry()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.canRetry, other.canRetry);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TIOError(");
+ boolean first = true;
+
+ if (isSetMessage()) {
+ sb.append("message:");
+ if (this.message == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.message);
+ }
+ first = false;
+ }
+ if (isSetCanRetry()) {
+ if (!first) sb.append(", ");
+ sb.append("canRetry:");
+ sb.append(this.canRetry);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TIOErrorStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIOErrorStandardScheme getScheme() {
+ return new TIOErrorStandardScheme();
+ }
+ }
+
+ private static class TIOErrorStandardScheme extends org.apache.thrift.scheme.StandardScheme<TIOError> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TIOError struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // MESSAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // CAN_RETRY
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.canRetry = iprot.readBool();
+ struct.setCanRetryIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TIOError struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.message != null) {
+ if (struct.isSetMessage()) {
+ oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+ oprot.writeString(struct.message);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetCanRetry()) {
+ oprot.writeFieldBegin(CAN_RETRY_FIELD_DESC);
+ oprot.writeBool(struct.canRetry);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TIOErrorTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIOErrorTupleScheme getScheme() {
+ return new TIOErrorTupleScheme();
+ }
+ }
+
+ private static class TIOErrorTupleScheme extends org.apache.thrift.scheme.TupleScheme<TIOError> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TIOError struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetMessage()) {
+ optionals.set(0);
+ }
+ if (struct.isSetCanRetry()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetMessage()) {
+ oprot.writeString(struct.message);
+ }
+ if (struct.isSetCanRetry()) {
+ oprot.writeBool(struct.canRetry);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TIOError struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.canRetry = iprot.readBool();
+ struct.setCanRetryIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIllegalArgument.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIllegalArgument.java
new file mode 100644
index 0000000..9b634c5
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIllegalArgument.java
@@ -0,0 +1,377 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * A TIllegalArgument exception indicates an illegal or invalid
+ * argument was passed into a procedure.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TIllegalArgument extends org.apache.thrift.TException implements org.apache.thrift.TBase<TIllegalArgument, TIllegalArgument._Fields>, java.io.Serializable, Cloneable, Comparable<TIllegalArgument> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIllegalArgument");
+
+ private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TIllegalArgumentStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TIllegalArgumentTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String message; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ MESSAGE((short)1, "message");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // MESSAGE
+ return MESSAGE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.MESSAGE};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TIllegalArgument.class, metaDataMap);
+ }
+
+ public TIllegalArgument() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TIllegalArgument(TIllegalArgument other) {
+ if (other.isSetMessage()) {
+ this.message = other.message;
+ }
+ }
+
+ public TIllegalArgument deepCopy() {
+ return new TIllegalArgument(this);
+ }
+
+ @Override
+ public void clear() {
+ this.message = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getMessage() {
+ return this.message;
+ }
+
+ public TIllegalArgument setMessage(@org.apache.thrift.annotation.Nullable java.lang.String message) {
+ this.message = message;
+ return this;
+ }
+
+ public void unsetMessage() {
+ this.message = null;
+ }
+
+ /** Returns true if field message is set (has been assigned a value) and false otherwise */
+ public boolean isSetMessage() {
+ return this.message != null;
+ }
+
+ public void setMessageIsSet(boolean value) {
+ if (!value) {
+ this.message = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case MESSAGE:
+ if (value == null) {
+ unsetMessage();
+ } else {
+ setMessage((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MESSAGE:
+ return getMessage();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case MESSAGE:
+ return isSetMessage();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TIllegalArgument)
+ return this.equals((TIllegalArgument)that);
+ return false;
+ }
+
+ public boolean equals(TIllegalArgument that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_message = true && this.isSetMessage();
+ boolean that_present_message = true && that.isSetMessage();
+ if (this_present_message || that_present_message) {
+ if (!(this_present_message && that_present_message))
+ return false;
+ if (!this.message.equals(that.message))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetMessage()) ? 131071 : 524287);
+ if (isSetMessage())
+ hashCode = hashCode * 8191 + message.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TIllegalArgument other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetMessage(), other.isSetMessage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMessage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.message, other.message);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TIllegalArgument(");
+ boolean first = true;
+
+ if (isSetMessage()) {
+ sb.append("message:");
+ if (this.message == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.message);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TIllegalArgumentStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIllegalArgumentStandardScheme getScheme() {
+ return new TIllegalArgumentStandardScheme();
+ }
+ }
+
+ private static class TIllegalArgumentStandardScheme extends org.apache.thrift.scheme.StandardScheme<TIllegalArgument> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TIllegalArgument struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // MESSAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TIllegalArgument struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.message != null) {
+ if (struct.isSetMessage()) {
+ oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+ oprot.writeString(struct.message);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TIllegalArgumentTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIllegalArgumentTupleScheme getScheme() {
+ return new TIllegalArgumentTupleScheme();
+ }
+ }
+
+ private static class TIllegalArgumentTupleScheme extends org.apache.thrift.scheme.TupleScheme<TIllegalArgument> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TIllegalArgument struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetMessage()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetMessage()) {
+ oprot.writeString(struct.message);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TIllegalArgument struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIncrement.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIncrement.java
new file mode 100644
index 0000000..746f219
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIncrement.java
@@ -0,0 +1,1045 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Used to perform Increment operations for a single row.
+ *
+ * You can specify how this Increment should be written to the write-ahead Log (WAL)
+ * by changing the durability. If you don't provide durability, it defaults to
+ * column family's default setting for durability.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TIncrement implements org.apache.thrift.TBase<TIncrement, TIncrement._Fields>, java.io.Serializable, Cloneable, Comparable<TIncrement> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIncrement");
+
+ 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)1);
+ 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)2);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)4);
+ private static final org.apache.thrift.protocol.TField DURABILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("durability", org.apache.thrift.protocol.TType.I32, (short)5);
+ private static final org.apache.thrift.protocol.TField CELL_VISIBILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("cellVisibility", org.apache.thrift.protocol.TType.STRUCT, (short)6);
+ private static final org.apache.thrift.protocol.TField RETURN_RESULTS_FIELD_DESC = new org.apache.thrift.protocol.TField("returnResults", org.apache.thrift.protocol.TType.BOOL, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TIncrementStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TIncrementTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumnIncrement> columns; // required
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ /**
+ *
+ * @see TDurability
+ */
+ public @org.apache.thrift.annotation.Nullable TDurability durability; // optional
+ public @org.apache.thrift.annotation.Nullable TCellVisibility cellVisibility; // optional
+ public boolean returnResults; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ COLUMNS((short)2, "columns"),
+ ATTRIBUTES((short)4, "attributes"),
+ /**
+ *
+ * @see TDurability
+ */
+ DURABILITY((short)5, "durability"),
+ CELL_VISIBILITY((short)6, "cellVisibility"),
+ RETURN_RESULTS((short)7, "returnResults");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // COLUMNS
+ return COLUMNS;
+ case 4: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 5: // DURABILITY
+ return DURABILITY;
+ case 6: // CELL_VISIBILITY
+ return CELL_VISIBILITY;
+ case 7: // RETURN_RESULTS
+ return RETURN_RESULTS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __RETURNRESULTS_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.ATTRIBUTES,_Fields.DURABILITY,_Fields.CELL_VISIBILITY,_Fields.RETURN_RESULTS};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TColumnIncrement.class))));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.DURABILITY, new org.apache.thrift.meta_data.FieldMetaData("durability", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDurability.class)));
+ tmpMap.put(_Fields.CELL_VISIBILITY, new org.apache.thrift.meta_data.FieldMetaData("cellVisibility", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCellVisibility.class)));
+ tmpMap.put(_Fields.RETURN_RESULTS, new org.apache.thrift.meta_data.FieldMetaData("returnResults", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TIncrement.class, metaDataMap);
+ }
+
+ public TIncrement() {
+ }
+
+ public TIncrement(
+ java.nio.ByteBuffer row,
+ java.util.List<TColumnIncrement> columns)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.columns = columns;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TIncrement(TIncrement other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<TColumnIncrement> __this__columns = new java.util.ArrayList<TColumnIncrement>(other.columns.size());
+ for (TColumnIncrement other_element : other.columns) {
+ __this__columns.add(new TColumnIncrement(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetDurability()) {
+ this.durability = other.durability;
+ }
+ if (other.isSetCellVisibility()) {
+ this.cellVisibility = new TCellVisibility(other.cellVisibility);
+ }
+ this.returnResults = other.returnResults;
+ }
+
+ public TIncrement deepCopy() {
+ return new TIncrement(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.columns = null;
+ this.attributes = null;
+ this.durability = null;
+ this.cellVisibility = null;
+ setReturnResultsIsSet(false);
+ this.returnResults = false;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TIncrement setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TIncrement setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumnIncrement> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(TColumnIncrement elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<TColumnIncrement>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumnIncrement> getColumns() {
+ return this.columns;
+ }
+
+ public TIncrement setColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumnIncrement> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TIncrement setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDurability getDurability() {
+ return this.durability;
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ public TIncrement setDurability(@org.apache.thrift.annotation.Nullable TDurability durability) {
+ this.durability = durability;
+ return this;
+ }
+
+ public void unsetDurability() {
+ this.durability = null;
+ }
+
+ /** Returns true if field durability is set (has been assigned a value) and false otherwise */
+ public boolean isSetDurability() {
+ return this.durability != null;
+ }
+
+ public void setDurabilityIsSet(boolean value) {
+ if (!value) {
+ this.durability = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TCellVisibility getCellVisibility() {
+ return this.cellVisibility;
+ }
+
+ public TIncrement setCellVisibility(@org.apache.thrift.annotation.Nullable TCellVisibility cellVisibility) {
+ this.cellVisibility = cellVisibility;
+ return this;
+ }
+
+ public void unsetCellVisibility() {
+ this.cellVisibility = null;
+ }
+
+ /** Returns true if field cellVisibility is set (has been assigned a value) and false otherwise */
+ public boolean isSetCellVisibility() {
+ return this.cellVisibility != null;
+ }
+
+ public void setCellVisibilityIsSet(boolean value) {
+ if (!value) {
+ this.cellVisibility = null;
+ }
+ }
+
+ public boolean isReturnResults() {
+ return this.returnResults;
+ }
+
+ public TIncrement setReturnResults(boolean returnResults) {
+ this.returnResults = returnResults;
+ setReturnResultsIsSet(true);
+ return this;
+ }
+
+ public void unsetReturnResults() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __RETURNRESULTS_ISSET_ID);
+ }
+
+ /** Returns true if field returnResults is set (has been assigned a value) and false otherwise */
+ public boolean isSetReturnResults() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __RETURNRESULTS_ISSET_ID);
+ }
+
+ public void setReturnResultsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __RETURNRESULTS_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<TColumnIncrement>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case DURABILITY:
+ if (value == null) {
+ unsetDurability();
+ } else {
+ setDurability((TDurability)value);
+ }
+ break;
+
+ case CELL_VISIBILITY:
+ if (value == null) {
+ unsetCellVisibility();
+ } else {
+ setCellVisibility((TCellVisibility)value);
+ }
+ break;
+
+ case RETURN_RESULTS:
+ if (value == null) {
+ unsetReturnResults();
+ } else {
+ setReturnResults((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case DURABILITY:
+ return getDurability();
+
+ case CELL_VISIBILITY:
+ return getCellVisibility();
+
+ case RETURN_RESULTS:
+ return isReturnResults();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case DURABILITY:
+ return isSetDurability();
+ case CELL_VISIBILITY:
+ return isSetCellVisibility();
+ case RETURN_RESULTS:
+ return isSetReturnResults();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TIncrement)
+ return this.equals((TIncrement)that);
+ return false;
+ }
+
+ public boolean equals(TIncrement that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_durability = true && this.isSetDurability();
+ boolean that_present_durability = true && that.isSetDurability();
+ if (this_present_durability || that_present_durability) {
+ if (!(this_present_durability && that_present_durability))
+ return false;
+ if (!this.durability.equals(that.durability))
+ return false;
+ }
+
+ boolean this_present_cellVisibility = true && this.isSetCellVisibility();
+ boolean that_present_cellVisibility = true && that.isSetCellVisibility();
+ if (this_present_cellVisibility || that_present_cellVisibility) {
+ if (!(this_present_cellVisibility && that_present_cellVisibility))
+ return false;
+ if (!this.cellVisibility.equals(that.cellVisibility))
+ return false;
+ }
+
+ boolean this_present_returnResults = true && this.isSetReturnResults();
+ boolean that_present_returnResults = true && that.isSetReturnResults();
+ if (this_present_returnResults || that_present_returnResults) {
+ if (!(this_present_returnResults && that_present_returnResults))
+ return false;
+ if (this.returnResults != that.returnResults)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetDurability()) ? 131071 : 524287);
+ if (isSetDurability())
+ hashCode = hashCode * 8191 + durability.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetCellVisibility()) ? 131071 : 524287);
+ if (isSetCellVisibility())
+ hashCode = hashCode * 8191 + cellVisibility.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetReturnResults()) ? 131071 : 524287);
+ if (isSetReturnResults())
+ hashCode = hashCode * 8191 + ((returnResults) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TIncrement other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDurability(), other.isSetDurability());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDurability()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.durability, other.durability);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCellVisibility(), other.isSetCellVisibility());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCellVisibility()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cellVisibility, other.cellVisibility);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetReturnResults(), other.isSetReturnResults());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReturnResults()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.returnResults, other.returnResults);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TIncrement(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columns);
+ }
+ first = false;
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetDurability()) {
+ if (!first) sb.append(", ");
+ sb.append("durability:");
+ if (this.durability == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.durability);
+ }
+ first = false;
+ }
+ if (isSetCellVisibility()) {
+ if (!first) sb.append(", ");
+ sb.append("cellVisibility:");
+ if (this.cellVisibility == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.cellVisibility);
+ }
+ first = false;
+ }
+ if (isSetReturnResults()) {
+ if (!first) sb.append(", ");
+ sb.append("returnResults:");
+ sb.append(this.returnResults);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ if (columns == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'columns' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (cellVisibility != null) {
+ cellVisibility.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TIncrementStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIncrementStandardScheme getScheme() {
+ return new TIncrementStandardScheme();
+ }
+ }
+
+ private static class TIncrementStandardScheme extends org.apache.thrift.scheme.StandardScheme<TIncrement> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list70 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<TColumnIncrement>(_list70.size);
+ @org.apache.thrift.annotation.Nullable TColumnIncrement _elem71;
+ for (int _i72 = 0; _i72 < _list70.size; ++_i72)
+ {
+ _elem71 = new TColumnIncrement();
+ _elem71.read(iprot);
+ struct.columns.add(_elem71);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map73 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map73.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key74;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val75;
+ for (int _i76 = 0; _i76 < _map73.size; ++_i76)
+ {
+ _key74 = iprot.readBinary();
+ _val75 = iprot.readBinary();
+ struct.attributes.put(_key74, _val75);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // DURABILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // CELL_VISIBILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.cellVisibility = new TCellVisibility();
+ struct.cellVisibility.read(iprot);
+ struct.setCellVisibilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // RETURN_RESULTS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.returnResults = iprot.readBool();
+ struct.setReturnResultsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TIncrement struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+ for (TColumnIncrement _iter77 : struct.columns)
+ {
+ _iter77.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter78 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter78.getKey());
+ oprot.writeBinary(_iter78.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.durability != null) {
+ if (struct.isSetDurability()) {
+ oprot.writeFieldBegin(DURABILITY_FIELD_DESC);
+ oprot.writeI32(struct.durability.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.cellVisibility != null) {
+ if (struct.isSetCellVisibility()) {
+ oprot.writeFieldBegin(CELL_VISIBILITY_FIELD_DESC);
+ struct.cellVisibility.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetReturnResults()) {
+ oprot.writeFieldBegin(RETURN_RESULTS_FIELD_DESC);
+ oprot.writeBool(struct.returnResults);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TIncrementTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TIncrementTupleScheme getScheme() {
+ return new TIncrementTupleScheme();
+ }
+ }
+
+ private static class TIncrementTupleScheme extends org.apache.thrift.scheme.TupleScheme<TIncrement> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.row);
+ {
+ oprot.writeI32(struct.columns.size());
+ for (TColumnIncrement _iter79 : struct.columns)
+ {
+ _iter79.write(oprot);
+ }
+ }
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetAttributes()) {
+ optionals.set(0);
+ }
+ if (struct.isSetDurability()) {
+ optionals.set(1);
+ }
+ if (struct.isSetCellVisibility()) {
+ optionals.set(2);
+ }
+ if (struct.isSetReturnResults()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter80 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter80.getKey());
+ oprot.writeBinary(_iter80.getValue());
+ }
+ }
+ }
+ if (struct.isSetDurability()) {
+ oprot.writeI32(struct.durability.getValue());
+ }
+ if (struct.isSetCellVisibility()) {
+ struct.cellVisibility.write(oprot);
+ }
+ if (struct.isSetReturnResults()) {
+ oprot.writeBool(struct.returnResults);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TIncrement struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list81 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columns = new java.util.ArrayList<TColumnIncrement>(_list81.size);
+ @org.apache.thrift.annotation.Nullable TColumnIncrement _elem82;
+ for (int _i83 = 0; _i83 < _list81.size; ++_i83)
+ {
+ _elem82 = new TColumnIncrement();
+ _elem82.read(iprot);
+ struct.columns.add(_elem82);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TMap _map84 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map84.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key85;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val86;
+ for (int _i87 = 0; _i87 < _map84.size; ++_i87)
+ {
+ _key85 = iprot.readBinary();
+ _val86 = iprot.readBinary();
+ struct.attributes.put(_key85, _val86);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.cellVisibility = new TCellVisibility();
+ struct.cellVisibility.read(iprot);
+ struct.setCellVisibilityIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.returnResults = iprot.readBool();
+ struct.setReturnResultsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TKeepDeletedCells.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TKeepDeletedCells.java
new file mode 100644
index 0000000..dd723fd
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TKeepDeletedCells.java
@@ -0,0 +1,65 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.KeepDeletedCells
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TKeepDeletedCells implements org.apache.thrift.TEnum {
+ /**
+ * Deleted Cells are not retained.
+ */
+ FALSE(0),
+ /**
+ * Deleted Cells are retained until they are removed by other means
+ * such TTL or VERSIONS.
+ * If no TTL is specified or no new versions of delete cells are
+ * written, they are retained forever.
+ */
+ TRUE(1),
+ /**
+ * Deleted Cells are retained until the delete marker expires due to TTL.
+ * This is useful when TTL is combined with MIN_VERSIONS and one
+ * wants to keep a minimum number of versions around but at the same
+ * time remove deleted cells after the TTL.
+ */
+ TTL(2);
+
+ private final int value;
+
+ private TKeepDeletedCells(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TKeepDeletedCells findByValue(int value) {
+ switch (value) {
+ case 0:
+ return FALSE;
+ case 1:
+ return TRUE;
+ case 2:
+ return TTL;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogQueryFilter.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogQueryFilter.java
new file mode 100644
index 0000000..49f7d5a
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogQueryFilter.java
@@ -0,0 +1,1055 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.LogQueryFilter
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TLogQueryFilter implements org.apache.thrift.TBase<TLogQueryFilter, TLogQueryFilter._Fields>, java.io.Serializable, Cloneable, Comparable<TLogQueryFilter> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TLogQueryFilter");
+
+ private static final org.apache.thrift.protocol.TField REGION_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("regionName", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField CLIENT_ADDRESS_FIELD_DESC = new org.apache.thrift.protocol.TField("clientAddress", org.apache.thrift.protocol.TType.STRING, (short)2);
+ 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)3);
+ private static final org.apache.thrift.protocol.TField USER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("userName", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I32, (short)5);
+ private static final org.apache.thrift.protocol.TField LOG_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("logType", org.apache.thrift.protocol.TType.I32, (short)6);
+ private static final org.apache.thrift.protocol.TField FILTER_BY_OPERATOR_FIELD_DESC = new org.apache.thrift.protocol.TField("filterByOperator", org.apache.thrift.protocol.TType.I32, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TLogQueryFilterStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TLogQueryFilterTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String regionName; // optional
+ public @org.apache.thrift.annotation.Nullable java.lang.String clientAddress; // optional
+ public @org.apache.thrift.annotation.Nullable java.lang.String tableName; // optional
+ public @org.apache.thrift.annotation.Nullable java.lang.String userName; // optional
+ public int limit; // optional
+ /**
+ *
+ * @see TLogType
+ */
+ public @org.apache.thrift.annotation.Nullable TLogType logType; // optional
+ /**
+ *
+ * @see TFilterByOperator
+ */
+ public @org.apache.thrift.annotation.Nullable TFilterByOperator filterByOperator; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REGION_NAME((short)1, "regionName"),
+ CLIENT_ADDRESS((short)2, "clientAddress"),
+ TABLE_NAME((short)3, "tableName"),
+ USER_NAME((short)4, "userName"),
+ LIMIT((short)5, "limit"),
+ /**
+ *
+ * @see TLogType
+ */
+ LOG_TYPE((short)6, "logType"),
+ /**
+ *
+ * @see TFilterByOperator
+ */
+ FILTER_BY_OPERATOR((short)7, "filterByOperator");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // REGION_NAME
+ return REGION_NAME;
+ case 2: // CLIENT_ADDRESS
+ return CLIENT_ADDRESS;
+ case 3: // TABLE_NAME
+ return TABLE_NAME;
+ case 4: // USER_NAME
+ return USER_NAME;
+ case 5: // LIMIT
+ return LIMIT;
+ case 6: // LOG_TYPE
+ return LOG_TYPE;
+ case 7: // FILTER_BY_OPERATOR
+ return FILTER_BY_OPERATOR;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __LIMIT_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.REGION_NAME,_Fields.CLIENT_ADDRESS,_Fields.TABLE_NAME,_Fields.USER_NAME,_Fields.LIMIT,_Fields.LOG_TYPE,_Fields.FILTER_BY_OPERATOR};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.REGION_NAME, new org.apache.thrift.meta_data.FieldMetaData("regionName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.CLIENT_ADDRESS, new org.apache.thrift.meta_data.FieldMetaData("clientAddress", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.USER_NAME, new org.apache.thrift.meta_data.FieldMetaData("userName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.LIMIT, new org.apache.thrift.meta_data.FieldMetaData("limit", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.LOG_TYPE, new org.apache.thrift.meta_data.FieldMetaData("logType", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TLogType.class)));
+ tmpMap.put(_Fields.FILTER_BY_OPERATOR, new org.apache.thrift.meta_data.FieldMetaData("filterByOperator", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TFilterByOperator.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TLogQueryFilter.class, metaDataMap);
+ }
+
+ public TLogQueryFilter() {
+ this.limit = 10;
+
+ this.logType = org.apache.hadoop.hbase.thrift2.generated.TLogType.SLOW_LOG;
+
+ this.filterByOperator = org.apache.hadoop.hbase.thrift2.generated.TFilterByOperator.OR;
+
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TLogQueryFilter(TLogQueryFilter other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRegionName()) {
+ this.regionName = other.regionName;
+ }
+ if (other.isSetClientAddress()) {
+ this.clientAddress = other.clientAddress;
+ }
+ if (other.isSetTableName()) {
+ this.tableName = other.tableName;
+ }
+ if (other.isSetUserName()) {
+ this.userName = other.userName;
+ }
+ this.limit = other.limit;
+ if (other.isSetLogType()) {
+ this.logType = other.logType;
+ }
+ if (other.isSetFilterByOperator()) {
+ this.filterByOperator = other.filterByOperator;
+ }
+ }
+
+ public TLogQueryFilter deepCopy() {
+ return new TLogQueryFilter(this);
+ }
+
+ @Override
+ public void clear() {
+ this.regionName = null;
+ this.clientAddress = null;
+ this.tableName = null;
+ this.userName = null;
+ this.limit = 10;
+
+ this.logType = org.apache.hadoop.hbase.thrift2.generated.TLogType.SLOW_LOG;
+
+ this.filterByOperator = org.apache.hadoop.hbase.thrift2.generated.TFilterByOperator.OR;
+
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getRegionName() {
+ return this.regionName;
+ }
+
+ public TLogQueryFilter setRegionName(@org.apache.thrift.annotation.Nullable java.lang.String regionName) {
+ this.regionName = regionName;
+ return this;
+ }
+
+ public void unsetRegionName() {
+ this.regionName = null;
+ }
+
+ /** Returns true if field regionName is set (has been assigned a value) and false otherwise */
+ public boolean isSetRegionName() {
+ return this.regionName != null;
+ }
+
+ public void setRegionNameIsSet(boolean value) {
+ if (!value) {
+ this.regionName = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getClientAddress() {
+ return this.clientAddress;
+ }
+
+ public TLogQueryFilter setClientAddress(@org.apache.thrift.annotation.Nullable java.lang.String clientAddress) {
+ this.clientAddress = clientAddress;
+ return this;
+ }
+
+ public void unsetClientAddress() {
+ this.clientAddress = null;
+ }
+
+ /** Returns true if field clientAddress is set (has been assigned a value) and false otherwise */
+ public boolean isSetClientAddress() {
+ return this.clientAddress != null;
+ }
+
+ public void setClientAddressIsSet(boolean value) {
+ if (!value) {
+ this.clientAddress = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getTableName() {
+ return this.tableName;
+ }
+
+ public TLogQueryFilter setTableName(@org.apache.thrift.annotation.Nullable java.lang.String tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getUserName() {
+ return this.userName;
+ }
+
+ public TLogQueryFilter setUserName(@org.apache.thrift.annotation.Nullable java.lang.String userName) {
+ this.userName = userName;
+ return this;
+ }
+
+ public void unsetUserName() {
+ this.userName = null;
+ }
+
+ /** Returns true if field userName is set (has been assigned a value) and false otherwise */
+ public boolean isSetUserName() {
+ return this.userName != null;
+ }
+
+ public void setUserNameIsSet(boolean value) {
+ if (!value) {
+ this.userName = null;
+ }
+ }
+
+ public int getLimit() {
+ return this.limit;
+ }
+
+ public TLogQueryFilter setLimit(int limit) {
+ this.limit = limit;
+ setLimitIsSet(true);
+ return this;
+ }
+
+ public void unsetLimit() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LIMIT_ISSET_ID);
+ }
+
+ /** Returns true if field limit is set (has been assigned a value) and false otherwise */
+ public boolean isSetLimit() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LIMIT_ISSET_ID);
+ }
+
+ public void setLimitIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LIMIT_ISSET_ID, value);
+ }
+
+ /**
+ *
+ * @see TLogType
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TLogType getLogType() {
+ return this.logType;
+ }
+
+ /**
+ *
+ * @see TLogType
+ */
+ public TLogQueryFilter setLogType(@org.apache.thrift.annotation.Nullable TLogType logType) {
+ this.logType = logType;
+ return this;
+ }
+
+ public void unsetLogType() {
+ this.logType = null;
+ }
+
+ /** Returns true if field logType is set (has been assigned a value) and false otherwise */
+ public boolean isSetLogType() {
+ return this.logType != null;
+ }
+
+ public void setLogTypeIsSet(boolean value) {
+ if (!value) {
+ this.logType = null;
+ }
+ }
+
+ /**
+ *
+ * @see TFilterByOperator
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TFilterByOperator getFilterByOperator() {
+ return this.filterByOperator;
+ }
+
+ /**
+ *
+ * @see TFilterByOperator
+ */
+ public TLogQueryFilter setFilterByOperator(@org.apache.thrift.annotation.Nullable TFilterByOperator filterByOperator) {
+ this.filterByOperator = filterByOperator;
+ return this;
+ }
+
+ public void unsetFilterByOperator() {
+ this.filterByOperator = null;
+ }
+
+ /** Returns true if field filterByOperator is set (has been assigned a value) and false otherwise */
+ public boolean isSetFilterByOperator() {
+ return this.filterByOperator != null;
+ }
+
+ public void setFilterByOperatorIsSet(boolean value) {
+ if (!value) {
+ this.filterByOperator = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case REGION_NAME:
+ if (value == null) {
+ unsetRegionName();
+ } else {
+ setRegionName((java.lang.String)value);
+ }
+ break;
+
+ case CLIENT_ADDRESS:
+ if (value == null) {
+ unsetClientAddress();
+ } else {
+ setClientAddress((java.lang.String)value);
+ }
+ break;
+
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((java.lang.String)value);
+ }
+ break;
+
+ case USER_NAME:
+ if (value == null) {
+ unsetUserName();
+ } else {
+ setUserName((java.lang.String)value);
+ }
+ break;
+
+ case LIMIT:
+ if (value == null) {
+ unsetLimit();
+ } else {
+ setLimit((java.lang.Integer)value);
+ }
+ break;
+
+ case LOG_TYPE:
+ if (value == null) {
+ unsetLogType();
+ } else {
+ setLogType((TLogType)value);
+ }
+ break;
+
+ case FILTER_BY_OPERATOR:
+ if (value == null) {
+ unsetFilterByOperator();
+ } else {
+ setFilterByOperator((TFilterByOperator)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REGION_NAME:
+ return getRegionName();
+
+ case CLIENT_ADDRESS:
+ return getClientAddress();
+
+ case TABLE_NAME:
+ return getTableName();
+
+ case USER_NAME:
+ return getUserName();
+
+ case LIMIT:
+ return getLimit();
+
+ case LOG_TYPE:
+ return getLogType();
+
+ case FILTER_BY_OPERATOR:
+ return getFilterByOperator();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case REGION_NAME:
+ return isSetRegionName();
+ case CLIENT_ADDRESS:
+ return isSetClientAddress();
+ case TABLE_NAME:
+ return isSetTableName();
+ case USER_NAME:
+ return isSetUserName();
+ case LIMIT:
+ return isSetLimit();
+ case LOG_TYPE:
+ return isSetLogType();
+ case FILTER_BY_OPERATOR:
+ return isSetFilterByOperator();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TLogQueryFilter)
+ return this.equals((TLogQueryFilter)that);
+ return false;
+ }
+
+ public boolean equals(TLogQueryFilter that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_regionName = true && this.isSetRegionName();
+ boolean that_present_regionName = true && that.isSetRegionName();
+ if (this_present_regionName || that_present_regionName) {
+ if (!(this_present_regionName && that_present_regionName))
+ return false;
+ if (!this.regionName.equals(that.regionName))
+ return false;
+ }
+
+ boolean this_present_clientAddress = true && this.isSetClientAddress();
+ boolean that_present_clientAddress = true && that.isSetClientAddress();
+ if (this_present_clientAddress || that_present_clientAddress) {
+ if (!(this_present_clientAddress && that_present_clientAddress))
+ return false;
+ if (!this.clientAddress.equals(that.clientAddress))
+ return false;
+ }
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_userName = true && this.isSetUserName();
+ boolean that_present_userName = true && that.isSetUserName();
+ if (this_present_userName || that_present_userName) {
+ if (!(this_present_userName && that_present_userName))
+ return false;
+ if (!this.userName.equals(that.userName))
+ return false;
+ }
+
+ boolean this_present_limit = true && this.isSetLimit();
+ boolean that_present_limit = true && that.isSetLimit();
+ if (this_present_limit || that_present_limit) {
+ if (!(this_present_limit && that_present_limit))
+ return false;
+ if (this.limit != that.limit)
+ return false;
+ }
+
+ boolean this_present_logType = true && this.isSetLogType();
+ boolean that_present_logType = true && that.isSetLogType();
+ if (this_present_logType || that_present_logType) {
+ if (!(this_present_logType && that_present_logType))
+ return false;
+ if (!this.logType.equals(that.logType))
+ return false;
+ }
+
+ boolean this_present_filterByOperator = true && this.isSetFilterByOperator();
+ boolean that_present_filterByOperator = true && that.isSetFilterByOperator();
+ if (this_present_filterByOperator || that_present_filterByOperator) {
+ if (!(this_present_filterByOperator && that_present_filterByOperator))
+ return false;
+ if (!this.filterByOperator.equals(that.filterByOperator))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRegionName()) ? 131071 : 524287);
+ if (isSetRegionName())
+ hashCode = hashCode * 8191 + regionName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetClientAddress()) ? 131071 : 524287);
+ if (isSetClientAddress())
+ hashCode = hashCode * 8191 + clientAddress.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetUserName()) ? 131071 : 524287);
+ if (isSetUserName())
+ hashCode = hashCode * 8191 + userName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetLimit()) ? 131071 : 524287);
+ if (isSetLimit())
+ hashCode = hashCode * 8191 + limit;
+
+ hashCode = hashCode * 8191 + ((isSetLogType()) ? 131071 : 524287);
+ if (isSetLogType())
+ hashCode = hashCode * 8191 + logType.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetFilterByOperator()) ? 131071 : 524287);
+ if (isSetFilterByOperator())
+ hashCode = hashCode * 8191 + filterByOperator.getValue();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TLogQueryFilter other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRegionName(), other.isSetRegionName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRegionName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.regionName, other.regionName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetClientAddress(), other.isSetClientAddress());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetClientAddress()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.clientAddress, other.clientAddress);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetUserName(), other.isSetUserName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetUserName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userName, other.userName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetLimit(), other.isSetLimit());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetLimit()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limit, other.limit);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetLogType(), other.isSetLogType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetLogType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.logType, other.logType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFilterByOperator(), other.isSetFilterByOperator());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFilterByOperator()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterByOperator, other.filterByOperator);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TLogQueryFilter(");
+ boolean first = true;
+
+ if (isSetRegionName()) {
+ sb.append("regionName:");
+ if (this.regionName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.regionName);
+ }
+ first = false;
+ }
+ if (isSetClientAddress()) {
+ if (!first) sb.append(", ");
+ sb.append("clientAddress:");
+ if (this.clientAddress == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.clientAddress);
+ }
+ first = false;
+ }
+ if (isSetTableName()) {
+ if (!first) sb.append(", ");
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ }
+ if (isSetUserName()) {
+ if (!first) sb.append(", ");
+ sb.append("userName:");
+ if (this.userName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.userName);
+ }
+ first = false;
+ }
+ if (isSetLimit()) {
+ if (!first) sb.append(", ");
+ sb.append("limit:");
+ sb.append(this.limit);
+ first = false;
+ }
+ if (isSetLogType()) {
+ if (!first) sb.append(", ");
+ sb.append("logType:");
+ if (this.logType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.logType);
+ }
+ first = false;
+ }
+ if (isSetFilterByOperator()) {
+ if (!first) sb.append(", ");
+ sb.append("filterByOperator:");
+ if (this.filterByOperator == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.filterByOperator);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TLogQueryFilterStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TLogQueryFilterStandardScheme getScheme() {
+ return new TLogQueryFilterStandardScheme();
+ }
+ }
+
+ private static class TLogQueryFilterStandardScheme extends org.apache.thrift.scheme.StandardScheme<TLogQueryFilter> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TLogQueryFilter struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // REGION_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.regionName = iprot.readString();
+ struct.setRegionNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // CLIENT_ADDRESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.clientAddress = iprot.readString();
+ struct.setClientAddressIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // USER_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.userName = iprot.readString();
+ struct.setUserNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // LIMIT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.limit = iprot.readI32();
+ struct.setLimitIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // LOG_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.logType = org.apache.hadoop.hbase.thrift2.generated.TLogType.findByValue(iprot.readI32());
+ struct.setLogTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // FILTER_BY_OPERATOR
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.filterByOperator = org.apache.hadoop.hbase.thrift2.generated.TFilterByOperator.findByValue(iprot.readI32());
+ struct.setFilterByOperatorIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TLogQueryFilter struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.regionName != null) {
+ if (struct.isSetRegionName()) {
+ oprot.writeFieldBegin(REGION_NAME_FIELD_DESC);
+ oprot.writeString(struct.regionName);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.clientAddress != null) {
+ if (struct.isSetClientAddress()) {
+ oprot.writeFieldBegin(CLIENT_ADDRESS_FIELD_DESC);
+ oprot.writeString(struct.clientAddress);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.tableName != null) {
+ if (struct.isSetTableName()) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeString(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.userName != null) {
+ if (struct.isSetUserName()) {
+ oprot.writeFieldBegin(USER_NAME_FIELD_DESC);
+ oprot.writeString(struct.userName);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetLimit()) {
+ oprot.writeFieldBegin(LIMIT_FIELD_DESC);
+ oprot.writeI32(struct.limit);
+ oprot.writeFieldEnd();
+ }
+ if (struct.logType != null) {
+ if (struct.isSetLogType()) {
+ oprot.writeFieldBegin(LOG_TYPE_FIELD_DESC);
+ oprot.writeI32(struct.logType.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.filterByOperator != null) {
+ if (struct.isSetFilterByOperator()) {
+ oprot.writeFieldBegin(FILTER_BY_OPERATOR_FIELD_DESC);
+ oprot.writeI32(struct.filterByOperator.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TLogQueryFilterTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TLogQueryFilterTupleScheme getScheme() {
+ return new TLogQueryFilterTupleScheme();
+ }
+ }
+
+ private static class TLogQueryFilterTupleScheme extends org.apache.thrift.scheme.TupleScheme<TLogQueryFilter> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TLogQueryFilter struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRegionName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetClientAddress()) {
+ optionals.set(1);
+ }
+ if (struct.isSetTableName()) {
+ optionals.set(2);
+ }
+ if (struct.isSetUserName()) {
+ optionals.set(3);
+ }
+ if (struct.isSetLimit()) {
+ optionals.set(4);
+ }
+ if (struct.isSetLogType()) {
+ optionals.set(5);
+ }
+ if (struct.isSetFilterByOperator()) {
+ optionals.set(6);
+ }
+ oprot.writeBitSet(optionals, 7);
+ if (struct.isSetRegionName()) {
+ oprot.writeString(struct.regionName);
+ }
+ if (struct.isSetClientAddress()) {
+ oprot.writeString(struct.clientAddress);
+ }
+ if (struct.isSetTableName()) {
+ oprot.writeString(struct.tableName);
+ }
+ if (struct.isSetUserName()) {
+ oprot.writeString(struct.userName);
+ }
+ if (struct.isSetLimit()) {
+ oprot.writeI32(struct.limit);
+ }
+ if (struct.isSetLogType()) {
+ oprot.writeI32(struct.logType.getValue());
+ }
+ if (struct.isSetFilterByOperator()) {
+ oprot.writeI32(struct.filterByOperator.getValue());
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TLogQueryFilter struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(7);
+ if (incoming.get(0)) {
+ struct.regionName = iprot.readString();
+ struct.setRegionNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.clientAddress = iprot.readString();
+ struct.setClientAddressIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.userName = iprot.readString();
+ struct.setUserNameIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.limit = iprot.readI32();
+ struct.setLimitIsSet(true);
+ }
+ if (incoming.get(5)) {
+ struct.logType = org.apache.hadoop.hbase.thrift2.generated.TLogType.findByValue(iprot.readI32());
+ struct.setLogTypeIsSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.filterByOperator = org.apache.hadoop.hbase.thrift2.generated.TFilterByOperator.findByValue(iprot.readI32());
+ struct.setFilterByOperatorIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogType.java
new file mode 100644
index 0000000..a353374
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogType.java
@@ -0,0 +1,43 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TLogType implements org.apache.thrift.TEnum {
+ SLOW_LOG(1),
+ LARGE_LOG(2);
+
+ private final int value;
+
+ private TLogType(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TLogType findByValue(int value) {
+ switch (value) {
+ case 1:
+ return SLOW_LOG;
+ case 2:
+ return LARGE_LOG;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TMutation.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TMutation.java
new file mode 100644
index 0000000..6039ac3
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TMutation.java
@@ -0,0 +1,348 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Atomic mutation for the specified row. It can be either Put or Delete.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TMutation extends org.apache.thrift.TUnion<TMutation, TMutation._Fields> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TMutation");
+ private static final org.apache.thrift.protocol.TField PUT_FIELD_DESC = new org.apache.thrift.protocol.TField("put", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField DELETE_SINGLE_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteSingle", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ PUT((short)1, "put"),
+ DELETE_SINGLE((short)2, "deleteSingle");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // PUT
+ return PUT;
+ case 2: // DELETE_SINGLE
+ return DELETE_SINGLE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
+ tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TMutation.class, metaDataMap);
+ }
+
+ public TMutation() {
+ super();
+ }
+
+ public TMutation(_Fields setField, java.lang.Object value) {
+ super(setField, value);
+ }
+
+ public TMutation(TMutation other) {
+ super(other);
+ }
+ public TMutation deepCopy() {
+ return new TMutation(this);
+ }
+
+ public static TMutation put(TPut value) {
+ TMutation x = new TMutation();
+ x.setPut(value);
+ return x;
+ }
+
+ public static TMutation deleteSingle(TDelete value) {
+ TMutation x = new TMutation();
+ x.setDeleteSingle(value);
+ return x;
+ }
+
+
+ @Override
+ protected void checkType(_Fields setField, java.lang.Object value) throws java.lang.ClassCastException {
+ switch (setField) {
+ case PUT:
+ if (value instanceof TPut) {
+ break;
+ }
+ throw new java.lang.ClassCastException("Was expecting value of type TPut for field 'put', but got " + value.getClass().getSimpleName());
+ case DELETE_SINGLE:
+ if (value instanceof TDelete) {
+ break;
+ }
+ throw new java.lang.ClassCastException("Was expecting value of type TDelete for field 'deleteSingle', but got " + value.getClass().getSimpleName());
+ default:
+ throw new java.lang.IllegalArgumentException("Unknown field id " + setField);
+ }
+ }
+
+ @Override
+ protected java.lang.Object standardSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TField field) throws org.apache.thrift.TException {
+ _Fields setField = _Fields.findByThriftId(field.id);
+ if (setField != null) {
+ switch (setField) {
+ case PUT:
+ if (field.type == PUT_FIELD_DESC.type) {
+ TPut put;
+ put = new TPut();
+ put.read(iprot);
+ return put;
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ return null;
+ }
+ case DELETE_SINGLE:
+ if (field.type == DELETE_SINGLE_FIELD_DESC.type) {
+ TDelete deleteSingle;
+ deleteSingle = new TDelete();
+ deleteSingle.read(iprot);
+ return deleteSingle;
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ return null;
+ }
+ default:
+ throw new java.lang.IllegalStateException("setField wasn't null, but didn't match any of the case statements!");
+ }
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ return null;
+ }
+ }
+
+ @Override
+ protected void standardSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ switch (setField_) {
+ case PUT:
+ TPut put = (TPut)value_;
+ put.write(oprot);
+ return;
+ case DELETE_SINGLE:
+ TDelete deleteSingle = (TDelete)value_;
+ deleteSingle.write(oprot);
+ return;
+ default:
+ throw new java.lang.IllegalStateException("Cannot write union with unknown field " + setField_);
+ }
+ }
+
+ @Override
+ protected java.lang.Object tupleSchemeReadValue(org.apache.thrift.protocol.TProtocol iprot, short fieldID) throws org.apache.thrift.TException {
+ _Fields setField = _Fields.findByThriftId(fieldID);
+ if (setField != null) {
+ switch (setField) {
+ case PUT:
+ TPut put;
+ put = new TPut();
+ put.read(iprot);
+ return put;
+ case DELETE_SINGLE:
+ TDelete deleteSingle;
+ deleteSingle = new TDelete();
+ deleteSingle.read(iprot);
+ return deleteSingle;
+ default:
+ throw new java.lang.IllegalStateException("setField wasn't null, but didn't match any of the case statements!");
+ }
+ } else {
+ throw new org.apache.thrift.protocol.TProtocolException("Couldn't find a field with field id " + fieldID);
+ }
+ }
+
+ @Override
+ protected void tupleSchemeWriteValue(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ switch (setField_) {
+ case PUT:
+ TPut put = (TPut)value_;
+ put.write(oprot);
+ return;
+ case DELETE_SINGLE:
+ TDelete deleteSingle = (TDelete)value_;
+ deleteSingle.write(oprot);
+ return;
+ default:
+ throw new java.lang.IllegalStateException("Cannot write union with unknown field " + setField_);
+ }
+ }
+
+ @Override
+ protected org.apache.thrift.protocol.TField getFieldDesc(_Fields setField) {
+ switch (setField) {
+ case PUT:
+ return PUT_FIELD_DESC;
+ case DELETE_SINGLE:
+ return DELETE_SINGLE_FIELD_DESC;
+ default:
+ throw new java.lang.IllegalArgumentException("Unknown field id " + setField);
+ }
+ }
+
+ @Override
+ protected org.apache.thrift.protocol.TStruct getStructDesc() {
+ return STRUCT_DESC;
+ }
+
+ @Override
+ protected _Fields enumForId(short id) {
+ return _Fields.findByThriftIdOrThrow(id);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+
+ public TPut getPut() {
+ if (getSetField() == _Fields.PUT) {
+ return (TPut)getFieldValue();
+ } else {
+ throw new java.lang.RuntimeException("Cannot get field 'put' because union is currently set to " + getFieldDesc(getSetField()).name);
+ }
+ }
+
+ public void setPut(TPut value) {
+ setField_ = _Fields.PUT;
+ value_ = java.util.Objects.requireNonNull(value,"_Fields.PUT");
+ }
+
+ public TDelete getDeleteSingle() {
+ if (getSetField() == _Fields.DELETE_SINGLE) {
+ return (TDelete)getFieldValue();
+ } else {
+ throw new java.lang.RuntimeException("Cannot get field 'deleteSingle' because union is currently set to " + getFieldDesc(getSetField()).name);
+ }
+ }
+
+ public void setDeleteSingle(TDelete value) {
+ setField_ = _Fields.DELETE_SINGLE;
+ value_ = java.util.Objects.requireNonNull(value,"_Fields.DELETE_SINGLE");
+ }
+
+ public boolean isSetPut() {
+ return setField_ == _Fields.PUT;
+ }
+
+
+ public boolean isSetDeleteSingle() {
+ return setField_ == _Fields.DELETE_SINGLE;
+ }
+
+
+ public boolean equals(java.lang.Object other) {
+ if (other instanceof TMutation) {
+ return equals((TMutation)other);
+ } else {
+ return false;
+ }
+ }
+
+ public boolean equals(TMutation other) {
+ return other != null && getSetField() == other.getSetField() && getFieldValue().equals(other.getFieldValue());
+ }
+
+ @Override
+ public int compareTo(TMutation other) {
+ int lastComparison = org.apache.thrift.TBaseHelper.compareTo(getSetField(), other.getSetField());
+ if (lastComparison == 0) {
+ return org.apache.thrift.TBaseHelper.compareTo(getFieldValue(), other.getFieldValue());
+ }
+ return lastComparison;
+ }
+
+
+ @Override
+ public int hashCode() {
+ java.util.List<java.lang.Object> list = new java.util.ArrayList<java.lang.Object>();
+ list.add(this.getClass().getName());
+ org.apache.thrift.TFieldIdEnum setField = getSetField();
+ if (setField != null) {
+ list.add(setField.getThriftFieldId());
+ java.lang.Object value = getFieldValue();
+ if (value instanceof org.apache.thrift.TEnum) {
+ list.add(((org.apache.thrift.TEnum)getFieldValue()).getValue());
+ } else {
+ list.add(value);
+ }
+ }
+ return list.hashCode();
+ }
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TNamespaceDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TNamespaceDescriptor.java
new file mode 100644
index 0000000..ad79d1f
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TNamespaceDescriptor.java
@@ -0,0 +1,535 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.NamespaceDescriptor
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TNamespaceDescriptor implements org.apache.thrift.TBase<TNamespaceDescriptor, TNamespaceDescriptor._Fields>, java.io.Serializable, Cloneable, Comparable<TNamespaceDescriptor> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TNamespaceDescriptor");
+
+ private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField CONFIGURATION_FIELD_DESC = new org.apache.thrift.protocol.TField("configuration", org.apache.thrift.protocol.TType.MAP, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TNamespaceDescriptorStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TNamespaceDescriptorTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String name; // required
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.lang.String,java.lang.String> configuration; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ NAME((short)1, "name"),
+ CONFIGURATION((short)2, "configuration");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NAME
+ return NAME;
+ case 2: // CONFIGURATION
+ return CONFIGURATION;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.CONFIGURATION};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.CONFIGURATION, new org.apache.thrift.meta_data.FieldMetaData("configuration", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TNamespaceDescriptor.class, metaDataMap);
+ }
+
+ public TNamespaceDescriptor() {
+ }
+
+ public TNamespaceDescriptor(
+ java.lang.String name)
+ {
+ this();
+ this.name = name;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TNamespaceDescriptor(TNamespaceDescriptor other) {
+ if (other.isSetName()) {
+ this.name = other.name;
+ }
+ if (other.isSetConfiguration()) {
+ java.util.Map<java.lang.String,java.lang.String> __this__configuration = new java.util.HashMap<java.lang.String,java.lang.String>(other.configuration);
+ this.configuration = __this__configuration;
+ }
+ }
+
+ public TNamespaceDescriptor deepCopy() {
+ return new TNamespaceDescriptor(this);
+ }
+
+ @Override
+ public void clear() {
+ this.name = null;
+ this.configuration = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getName() {
+ return this.name;
+ }
+
+ public TNamespaceDescriptor setName(@org.apache.thrift.annotation.Nullable java.lang.String name) {
+ this.name = name;
+ return this;
+ }
+
+ public void unsetName() {
+ this.name = null;
+ }
+
+ /** Returns true if field name is set (has been assigned a value) and false otherwise */
+ public boolean isSetName() {
+ return this.name != null;
+ }
+
+ public void setNameIsSet(boolean value) {
+ if (!value) {
+ this.name = null;
+ }
+ }
+
+ public int getConfigurationSize() {
+ return (this.configuration == null) ? 0 : this.configuration.size();
+ }
+
+ public void putToConfiguration(java.lang.String key, java.lang.String val) {
+ if (this.configuration == null) {
+ this.configuration = new java.util.HashMap<java.lang.String,java.lang.String>();
+ }
+ this.configuration.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.lang.String,java.lang.String> getConfiguration() {
+ return this.configuration;
+ }
+
+ public TNamespaceDescriptor setConfiguration(@org.apache.thrift.annotation.Nullable java.util.Map<java.lang.String,java.lang.String> configuration) {
+ this.configuration = configuration;
+ return this;
+ }
+
+ public void unsetConfiguration() {
+ this.configuration = null;
+ }
+
+ /** Returns true if field configuration is set (has been assigned a value) and false otherwise */
+ public boolean isSetConfiguration() {
+ return this.configuration != null;
+ }
+
+ public void setConfigurationIsSet(boolean value) {
+ if (!value) {
+ this.configuration = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NAME:
+ if (value == null) {
+ unsetName();
+ } else {
+ setName((java.lang.String)value);
+ }
+ break;
+
+ case CONFIGURATION:
+ if (value == null) {
+ unsetConfiguration();
+ } else {
+ setConfiguration((java.util.Map<java.lang.String,java.lang.String>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NAME:
+ return getName();
+
+ case CONFIGURATION:
+ return getConfiguration();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NAME:
+ return isSetName();
+ case CONFIGURATION:
+ return isSetConfiguration();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TNamespaceDescriptor)
+ return this.equals((TNamespaceDescriptor)that);
+ return false;
+ }
+
+ public boolean equals(TNamespaceDescriptor that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_name = true && this.isSetName();
+ boolean that_present_name = true && that.isSetName();
+ if (this_present_name || that_present_name) {
+ if (!(this_present_name && that_present_name))
+ return false;
+ if (!this.name.equals(that.name))
+ return false;
+ }
+
+ boolean this_present_configuration = true && this.isSetConfiguration();
+ boolean that_present_configuration = true && that.isSetConfiguration();
+ if (this_present_configuration || that_present_configuration) {
+ if (!(this_present_configuration && that_present_configuration))
+ return false;
+ if (!this.configuration.equals(that.configuration))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+ if (isSetName())
+ hashCode = hashCode * 8191 + name.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetConfiguration()) ? 131071 : 524287);
+ if (isSetConfiguration())
+ hashCode = hashCode * 8191 + configuration.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TNamespaceDescriptor other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetName(), other.isSetName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetConfiguration(), other.isSetConfiguration());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetConfiguration()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.configuration, other.configuration);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TNamespaceDescriptor(");
+ boolean first = true;
+
+ sb.append("name:");
+ if (this.name == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.name);
+ }
+ first = false;
+ if (isSetConfiguration()) {
+ if (!first) sb.append(", ");
+ sb.append("configuration:");
+ if (this.configuration == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.configuration);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (name == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TNamespaceDescriptorStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TNamespaceDescriptorStandardScheme getScheme() {
+ return new TNamespaceDescriptorStandardScheme();
+ }
+ }
+
+ private static class TNamespaceDescriptorStandardScheme extends org.apache.thrift.scheme.StandardScheme<TNamespaceDescriptor> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TNamespaceDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // CONFIGURATION
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map180 = iprot.readMapBegin();
+ struct.configuration = new java.util.HashMap<java.lang.String,java.lang.String>(2*_map180.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _key181;
+ @org.apache.thrift.annotation.Nullable java.lang.String _val182;
+ for (int _i183 = 0; _i183 < _map180.size; ++_i183)
+ {
+ _key181 = iprot.readString();
+ _val182 = iprot.readString();
+ struct.configuration.put(_key181, _val182);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setConfigurationIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TNamespaceDescriptor struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.name != null) {
+ oprot.writeFieldBegin(NAME_FIELD_DESC);
+ oprot.writeString(struct.name);
+ oprot.writeFieldEnd();
+ }
+ if (struct.configuration != null) {
+ if (struct.isSetConfiguration()) {
+ oprot.writeFieldBegin(CONFIGURATION_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.configuration.size()));
+ for (java.util.Map.Entry<java.lang.String, java.lang.String> _iter184 : struct.configuration.entrySet())
+ {
+ oprot.writeString(_iter184.getKey());
+ oprot.writeString(_iter184.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TNamespaceDescriptorTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TNamespaceDescriptorTupleScheme getScheme() {
+ return new TNamespaceDescriptorTupleScheme();
+ }
+ }
+
+ private static class TNamespaceDescriptorTupleScheme extends org.apache.thrift.scheme.TupleScheme<TNamespaceDescriptor> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TNamespaceDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.name);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetConfiguration()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetConfiguration()) {
+ {
+ oprot.writeI32(struct.configuration.size());
+ for (java.util.Map.Entry<java.lang.String, java.lang.String> _iter185 : struct.configuration.entrySet())
+ {
+ oprot.writeString(_iter185.getKey());
+ oprot.writeString(_iter185.getValue());
+ }
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TNamespaceDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.name = iprot.readString();
+ struct.setNameIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TMap _map186 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.configuration = new java.util.HashMap<java.lang.String,java.lang.String>(2*_map186.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _key187;
+ @org.apache.thrift.annotation.Nullable java.lang.String _val188;
+ for (int _i189 = 0; _i189 < _map186.size; ++_i189)
+ {
+ _key187 = iprot.readString();
+ _val188 = iprot.readString();
+ struct.configuration.put(_key187, _val188);
+ }
+ }
+ struct.setConfigurationIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TOnlineLogRecord.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TOnlineLogRecord.java
new file mode 100644
index 0000000..4dcfb75
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TOnlineLogRecord.java
@@ -0,0 +1,1643 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.OnlineLogRecordrd
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TOnlineLogRecord implements org.apache.thrift.TBase<TOnlineLogRecord, TOnlineLogRecord._Fields>, java.io.Serializable, Cloneable, Comparable<TOnlineLogRecord> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TOnlineLogRecord");
+
+ private static final org.apache.thrift.protocol.TField START_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("startTime", org.apache.thrift.protocol.TType.I64, (short)1);
+ private static final org.apache.thrift.protocol.TField PROCESSING_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("processingTime", org.apache.thrift.protocol.TType.I32, (short)2);
+ private static final org.apache.thrift.protocol.TField QUEUE_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("queueTime", org.apache.thrift.protocol.TType.I32, (short)3);
+ private static final org.apache.thrift.protocol.TField RESPONSE_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("responseSize", org.apache.thrift.protocol.TType.I64, (short)4);
+ private static final org.apache.thrift.protocol.TField CLIENT_ADDRESS_FIELD_DESC = new org.apache.thrift.protocol.TField("clientAddress", org.apache.thrift.protocol.TType.STRING, (short)5);
+ private static final org.apache.thrift.protocol.TField SERVER_CLASS_FIELD_DESC = new org.apache.thrift.protocol.TField("serverClass", org.apache.thrift.protocol.TType.STRING, (short)6);
+ private static final org.apache.thrift.protocol.TField METHOD_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("methodName", org.apache.thrift.protocol.TType.STRING, (short)7);
+ private static final org.apache.thrift.protocol.TField CALL_DETAILS_FIELD_DESC = new org.apache.thrift.protocol.TField("callDetails", org.apache.thrift.protocol.TType.STRING, (short)8);
+ private static final org.apache.thrift.protocol.TField PARAM_FIELD_DESC = new org.apache.thrift.protocol.TField("param", org.apache.thrift.protocol.TType.STRING, (short)9);
+ private static final org.apache.thrift.protocol.TField USER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("userName", org.apache.thrift.protocol.TType.STRING, (short)10);
+ private static final org.apache.thrift.protocol.TField MULTI_GETS_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("multiGetsCount", org.apache.thrift.protocol.TType.I32, (short)11);
+ private static final org.apache.thrift.protocol.TField MULTI_MUTATIONS_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("multiMutationsCount", org.apache.thrift.protocol.TType.I32, (short)12);
+ private static final org.apache.thrift.protocol.TField MULTI_SERVICE_CALLS_FIELD_DESC = new org.apache.thrift.protocol.TField("multiServiceCalls", org.apache.thrift.protocol.TType.I32, (short)13);
+ private static final org.apache.thrift.protocol.TField REGION_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("regionName", org.apache.thrift.protocol.TType.STRING, (short)14);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TOnlineLogRecordStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TOnlineLogRecordTupleSchemeFactory();
+
+ public long startTime; // required
+ public int processingTime; // required
+ public int queueTime; // required
+ public long responseSize; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String clientAddress; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String serverClass; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String methodName; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String callDetails; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String param; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String userName; // required
+ public int multiGetsCount; // required
+ public int multiMutationsCount; // required
+ public int multiServiceCalls; // required
+ public @org.apache.thrift.annotation.Nullable java.lang.String regionName; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ START_TIME((short)1, "startTime"),
+ PROCESSING_TIME((short)2, "processingTime"),
+ QUEUE_TIME((short)3, "queueTime"),
+ RESPONSE_SIZE((short)4, "responseSize"),
+ CLIENT_ADDRESS((short)5, "clientAddress"),
+ SERVER_CLASS((short)6, "serverClass"),
+ METHOD_NAME((short)7, "methodName"),
+ CALL_DETAILS((short)8, "callDetails"),
+ PARAM((short)9, "param"),
+ USER_NAME((short)10, "userName"),
+ MULTI_GETS_COUNT((short)11, "multiGetsCount"),
+ MULTI_MUTATIONS_COUNT((short)12, "multiMutationsCount"),
+ MULTI_SERVICE_CALLS((short)13, "multiServiceCalls"),
+ REGION_NAME((short)14, "regionName");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // START_TIME
+ return START_TIME;
+ case 2: // PROCESSING_TIME
+ return PROCESSING_TIME;
+ case 3: // QUEUE_TIME
+ return QUEUE_TIME;
+ case 4: // RESPONSE_SIZE
+ return RESPONSE_SIZE;
+ case 5: // CLIENT_ADDRESS
+ return CLIENT_ADDRESS;
+ case 6: // SERVER_CLASS
+ return SERVER_CLASS;
+ case 7: // METHOD_NAME
+ return METHOD_NAME;
+ case 8: // CALL_DETAILS
+ return CALL_DETAILS;
+ case 9: // PARAM
+ return PARAM;
+ case 10: // USER_NAME
+ return USER_NAME;
+ case 11: // MULTI_GETS_COUNT
+ return MULTI_GETS_COUNT;
+ case 12: // MULTI_MUTATIONS_COUNT
+ return MULTI_MUTATIONS_COUNT;
+ case 13: // MULTI_SERVICE_CALLS
+ return MULTI_SERVICE_CALLS;
+ case 14: // REGION_NAME
+ return REGION_NAME;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __STARTTIME_ISSET_ID = 0;
+ private static final int __PROCESSINGTIME_ISSET_ID = 1;
+ private static final int __QUEUETIME_ISSET_ID = 2;
+ private static final int __RESPONSESIZE_ISSET_ID = 3;
+ private static final int __MULTIGETSCOUNT_ISSET_ID = 4;
+ private static final int __MULTIMUTATIONSCOUNT_ISSET_ID = 5;
+ private static final int __MULTISERVICECALLS_ISSET_ID = 6;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.REGION_NAME};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.START_TIME, new org.apache.thrift.meta_data.FieldMetaData("startTime", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ tmpMap.put(_Fields.PROCESSING_TIME, new org.apache.thrift.meta_data.FieldMetaData("processingTime", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.QUEUE_TIME, new org.apache.thrift.meta_data.FieldMetaData("queueTime", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.RESPONSE_SIZE, new org.apache.thrift.meta_data.FieldMetaData("responseSize", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ tmpMap.put(_Fields.CLIENT_ADDRESS, new org.apache.thrift.meta_data.FieldMetaData("clientAddress", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.SERVER_CLASS, new org.apache.thrift.meta_data.FieldMetaData("serverClass", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.METHOD_NAME, new org.apache.thrift.meta_data.FieldMetaData("methodName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.CALL_DETAILS, new org.apache.thrift.meta_data.FieldMetaData("callDetails", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.PARAM, new org.apache.thrift.meta_data.FieldMetaData("param", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.USER_NAME, new org.apache.thrift.meta_data.FieldMetaData("userName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.MULTI_GETS_COUNT, new org.apache.thrift.meta_data.FieldMetaData("multiGetsCount", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.MULTI_MUTATIONS_COUNT, new org.apache.thrift.meta_data.FieldMetaData("multiMutationsCount", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.MULTI_SERVICE_CALLS, new org.apache.thrift.meta_data.FieldMetaData("multiServiceCalls", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.REGION_NAME, new org.apache.thrift.meta_data.FieldMetaData("regionName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TOnlineLogRecord.class, metaDataMap);
+ }
+
+ public TOnlineLogRecord() {
+ }
+
+ public TOnlineLogRecord(
+ long startTime,
+ int processingTime,
+ int queueTime,
+ long responseSize,
+ java.lang.String clientAddress,
+ java.lang.String serverClass,
+ java.lang.String methodName,
+ java.lang.String callDetails,
+ java.lang.String param,
+ java.lang.String userName,
+ int multiGetsCount,
+ int multiMutationsCount,
+ int multiServiceCalls)
+ {
+ this();
+ this.startTime = startTime;
+ setStartTimeIsSet(true);
+ this.processingTime = processingTime;
+ setProcessingTimeIsSet(true);
+ this.queueTime = queueTime;
+ setQueueTimeIsSet(true);
+ this.responseSize = responseSize;
+ setResponseSizeIsSet(true);
+ this.clientAddress = clientAddress;
+ this.serverClass = serverClass;
+ this.methodName = methodName;
+ this.callDetails = callDetails;
+ this.param = param;
+ this.userName = userName;
+ this.multiGetsCount = multiGetsCount;
+ setMultiGetsCountIsSet(true);
+ this.multiMutationsCount = multiMutationsCount;
+ setMultiMutationsCountIsSet(true);
+ this.multiServiceCalls = multiServiceCalls;
+ setMultiServiceCallsIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TOnlineLogRecord(TOnlineLogRecord other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.startTime = other.startTime;
+ this.processingTime = other.processingTime;
+ this.queueTime = other.queueTime;
+ this.responseSize = other.responseSize;
+ if (other.isSetClientAddress()) {
+ this.clientAddress = other.clientAddress;
+ }
+ if (other.isSetServerClass()) {
+ this.serverClass = other.serverClass;
+ }
+ if (other.isSetMethodName()) {
+ this.methodName = other.methodName;
+ }
+ if (other.isSetCallDetails()) {
+ this.callDetails = other.callDetails;
+ }
+ if (other.isSetParam()) {
+ this.param = other.param;
+ }
+ if (other.isSetUserName()) {
+ this.userName = other.userName;
+ }
+ this.multiGetsCount = other.multiGetsCount;
+ this.multiMutationsCount = other.multiMutationsCount;
+ this.multiServiceCalls = other.multiServiceCalls;
+ if (other.isSetRegionName()) {
+ this.regionName = other.regionName;
+ }
+ }
+
+ public TOnlineLogRecord deepCopy() {
+ return new TOnlineLogRecord(this);
+ }
+
+ @Override
+ public void clear() {
+ setStartTimeIsSet(false);
+ this.startTime = 0;
+ setProcessingTimeIsSet(false);
+ this.processingTime = 0;
+ setQueueTimeIsSet(false);
+ this.queueTime = 0;
+ setResponseSizeIsSet(false);
+ this.responseSize = 0;
+ this.clientAddress = null;
+ this.serverClass = null;
+ this.methodName = null;
+ this.callDetails = null;
+ this.param = null;
+ this.userName = null;
+ setMultiGetsCountIsSet(false);
+ this.multiGetsCount = 0;
+ setMultiMutationsCountIsSet(false);
+ this.multiMutationsCount = 0;
+ setMultiServiceCallsIsSet(false);
+ this.multiServiceCalls = 0;
+ this.regionName = null;
+ }
+
+ public long getStartTime() {
+ return this.startTime;
+ }
+
+ public TOnlineLogRecord setStartTime(long startTime) {
+ this.startTime = startTime;
+ setStartTimeIsSet(true);
+ return this;
+ }
+
+ public void unsetStartTime() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __STARTTIME_ISSET_ID);
+ }
+
+ /** Returns true if field startTime is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartTime() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __STARTTIME_ISSET_ID);
+ }
+
+ public void setStartTimeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __STARTTIME_ISSET_ID, value);
+ }
+
+ public int getProcessingTime() {
+ return this.processingTime;
+ }
+
+ public TOnlineLogRecord setProcessingTime(int processingTime) {
+ this.processingTime = processingTime;
+ setProcessingTimeIsSet(true);
+ return this;
+ }
+
+ public void unsetProcessingTime() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PROCESSINGTIME_ISSET_ID);
+ }
+
+ /** Returns true if field processingTime is set (has been assigned a value) and false otherwise */
+ public boolean isSetProcessingTime() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PROCESSINGTIME_ISSET_ID);
+ }
+
+ public void setProcessingTimeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PROCESSINGTIME_ISSET_ID, value);
+ }
+
+ public int getQueueTime() {
+ return this.queueTime;
+ }
+
+ public TOnlineLogRecord setQueueTime(int queueTime) {
+ this.queueTime = queueTime;
+ setQueueTimeIsSet(true);
+ return this;
+ }
+
+ public void unsetQueueTime() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __QUEUETIME_ISSET_ID);
+ }
+
+ /** Returns true if field queueTime is set (has been assigned a value) and false otherwise */
+ public boolean isSetQueueTime() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __QUEUETIME_ISSET_ID);
+ }
+
+ public void setQueueTimeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __QUEUETIME_ISSET_ID, value);
+ }
+
+ public long getResponseSize() {
+ return this.responseSize;
+ }
+
+ public TOnlineLogRecord setResponseSize(long responseSize) {
+ this.responseSize = responseSize;
+ setResponseSizeIsSet(true);
+ return this;
+ }
+
+ public void unsetResponseSize() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __RESPONSESIZE_ISSET_ID);
+ }
+
+ /** Returns true if field responseSize is set (has been assigned a value) and false otherwise */
+ public boolean isSetResponseSize() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __RESPONSESIZE_ISSET_ID);
+ }
+
+ public void setResponseSizeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __RESPONSESIZE_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getClientAddress() {
+ return this.clientAddress;
+ }
+
+ public TOnlineLogRecord setClientAddress(@org.apache.thrift.annotation.Nullable java.lang.String clientAddress) {
+ this.clientAddress = clientAddress;
+ return this;
+ }
+
+ public void unsetClientAddress() {
+ this.clientAddress = null;
+ }
+
+ /** Returns true if field clientAddress is set (has been assigned a value) and false otherwise */
+ public boolean isSetClientAddress() {
+ return this.clientAddress != null;
+ }
+
+ public void setClientAddressIsSet(boolean value) {
+ if (!value) {
+ this.clientAddress = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getServerClass() {
+ return this.serverClass;
+ }
+
+ public TOnlineLogRecord setServerClass(@org.apache.thrift.annotation.Nullable java.lang.String serverClass) {
+ this.serverClass = serverClass;
+ return this;
+ }
+
+ public void unsetServerClass() {
+ this.serverClass = null;
+ }
+
+ /** Returns true if field serverClass is set (has been assigned a value) and false otherwise */
+ public boolean isSetServerClass() {
+ return this.serverClass != null;
+ }
+
+ public void setServerClassIsSet(boolean value) {
+ if (!value) {
+ this.serverClass = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getMethodName() {
+ return this.methodName;
+ }
+
+ public TOnlineLogRecord setMethodName(@org.apache.thrift.annotation.Nullable java.lang.String methodName) {
+ this.methodName = methodName;
+ return this;
+ }
+
+ public void unsetMethodName() {
+ this.methodName = null;
+ }
+
+ /** Returns true if field methodName is set (has been assigned a value) and false otherwise */
+ public boolean isSetMethodName() {
+ return this.methodName != null;
+ }
+
+ public void setMethodNameIsSet(boolean value) {
+ if (!value) {
+ this.methodName = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getCallDetails() {
+ return this.callDetails;
+ }
+
+ public TOnlineLogRecord setCallDetails(@org.apache.thrift.annotation.Nullable java.lang.String callDetails) {
+ this.callDetails = callDetails;
+ return this;
+ }
+
+ public void unsetCallDetails() {
+ this.callDetails = null;
+ }
+
+ /** Returns true if field callDetails is set (has been assigned a value) and false otherwise */
+ public boolean isSetCallDetails() {
+ return this.callDetails != null;
+ }
+
+ public void setCallDetailsIsSet(boolean value) {
+ if (!value) {
+ this.callDetails = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getParam() {
+ return this.param;
+ }
+
+ public TOnlineLogRecord setParam(@org.apache.thrift.annotation.Nullable java.lang.String param) {
+ this.param = param;
+ return this;
+ }
+
+ public void unsetParam() {
+ this.param = null;
+ }
+
+ /** Returns true if field param is set (has been assigned a value) and false otherwise */
+ public boolean isSetParam() {
+ return this.param != null;
+ }
+
+ public void setParamIsSet(boolean value) {
+ if (!value) {
+ this.param = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getUserName() {
+ return this.userName;
+ }
+
+ public TOnlineLogRecord setUserName(@org.apache.thrift.annotation.Nullable java.lang.String userName) {
+ this.userName = userName;
+ return this;
+ }
+
+ public void unsetUserName() {
+ this.userName = null;
+ }
+
+ /** Returns true if field userName is set (has been assigned a value) and false otherwise */
+ public boolean isSetUserName() {
+ return this.userName != null;
+ }
+
+ public void setUserNameIsSet(boolean value) {
+ if (!value) {
+ this.userName = null;
+ }
+ }
+
+ public int getMultiGetsCount() {
+ return this.multiGetsCount;
+ }
+
+ public TOnlineLogRecord setMultiGetsCount(int multiGetsCount) {
+ this.multiGetsCount = multiGetsCount;
+ setMultiGetsCountIsSet(true);
+ return this;
+ }
+
+ public void unsetMultiGetsCount() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MULTIGETSCOUNT_ISSET_ID);
+ }
+
+ /** Returns true if field multiGetsCount is set (has been assigned a value) and false otherwise */
+ public boolean isSetMultiGetsCount() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MULTIGETSCOUNT_ISSET_ID);
+ }
+
+ public void setMultiGetsCountIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MULTIGETSCOUNT_ISSET_ID, value);
+ }
+
+ public int getMultiMutationsCount() {
+ return this.multiMutationsCount;
+ }
+
+ public TOnlineLogRecord setMultiMutationsCount(int multiMutationsCount) {
+ this.multiMutationsCount = multiMutationsCount;
+ setMultiMutationsCountIsSet(true);
+ return this;
+ }
+
+ public void unsetMultiMutationsCount() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MULTIMUTATIONSCOUNT_ISSET_ID);
+ }
+
+ /** Returns true if field multiMutationsCount is set (has been assigned a value) and false otherwise */
+ public boolean isSetMultiMutationsCount() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MULTIMUTATIONSCOUNT_ISSET_ID);
+ }
+
+ public void setMultiMutationsCountIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MULTIMUTATIONSCOUNT_ISSET_ID, value);
+ }
+
+ public int getMultiServiceCalls() {
+ return this.multiServiceCalls;
+ }
+
+ public TOnlineLogRecord setMultiServiceCalls(int multiServiceCalls) {
+ this.multiServiceCalls = multiServiceCalls;
+ setMultiServiceCallsIsSet(true);
+ return this;
+ }
+
+ public void unsetMultiServiceCalls() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MULTISERVICECALLS_ISSET_ID);
+ }
+
+ /** Returns true if field multiServiceCalls is set (has been assigned a value) and false otherwise */
+ public boolean isSetMultiServiceCalls() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MULTISERVICECALLS_ISSET_ID);
+ }
+
+ public void setMultiServiceCallsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MULTISERVICECALLS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getRegionName() {
+ return this.regionName;
+ }
+
+ public TOnlineLogRecord setRegionName(@org.apache.thrift.annotation.Nullable java.lang.String regionName) {
+ this.regionName = regionName;
+ return this;
+ }
+
+ public void unsetRegionName() {
+ this.regionName = null;
+ }
+
+ /** Returns true if field regionName is set (has been assigned a value) and false otherwise */
+ public boolean isSetRegionName() {
+ return this.regionName != null;
+ }
+
+ public void setRegionNameIsSet(boolean value) {
+ if (!value) {
+ this.regionName = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case START_TIME:
+ if (value == null) {
+ unsetStartTime();
+ } else {
+ setStartTime((java.lang.Long)value);
+ }
+ break;
+
+ case PROCESSING_TIME:
+ if (value == null) {
+ unsetProcessingTime();
+ } else {
+ setProcessingTime((java.lang.Integer)value);
+ }
+ break;
+
+ case QUEUE_TIME:
+ if (value == null) {
+ unsetQueueTime();
+ } else {
+ setQueueTime((java.lang.Integer)value);
+ }
+ break;
+
+ case RESPONSE_SIZE:
+ if (value == null) {
+ unsetResponseSize();
+ } else {
+ setResponseSize((java.lang.Long)value);
+ }
+ break;
+
+ case CLIENT_ADDRESS:
+ if (value == null) {
+ unsetClientAddress();
+ } else {
+ setClientAddress((java.lang.String)value);
+ }
+ break;
+
+ case SERVER_CLASS:
+ if (value == null) {
+ unsetServerClass();
+ } else {
+ setServerClass((java.lang.String)value);
+ }
+ break;
+
+ case METHOD_NAME:
+ if (value == null) {
+ unsetMethodName();
+ } else {
+ setMethodName((java.lang.String)value);
+ }
+ break;
+
+ case CALL_DETAILS:
+ if (value == null) {
+ unsetCallDetails();
+ } else {
+ setCallDetails((java.lang.String)value);
+ }
+ break;
+
+ case PARAM:
+ if (value == null) {
+ unsetParam();
+ } else {
+ setParam((java.lang.String)value);
+ }
+ break;
+
+ case USER_NAME:
+ if (value == null) {
+ unsetUserName();
+ } else {
+ setUserName((java.lang.String)value);
+ }
+ break;
+
+ case MULTI_GETS_COUNT:
+ if (value == null) {
+ unsetMultiGetsCount();
+ } else {
+ setMultiGetsCount((java.lang.Integer)value);
+ }
+ break;
+
+ case MULTI_MUTATIONS_COUNT:
+ if (value == null) {
+ unsetMultiMutationsCount();
+ } else {
+ setMultiMutationsCount((java.lang.Integer)value);
+ }
+ break;
+
+ case MULTI_SERVICE_CALLS:
+ if (value == null) {
+ unsetMultiServiceCalls();
+ } else {
+ setMultiServiceCalls((java.lang.Integer)value);
+ }
+ break;
+
+ case REGION_NAME:
+ if (value == null) {
+ unsetRegionName();
+ } else {
+ setRegionName((java.lang.String)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case START_TIME:
+ return getStartTime();
+
+ case PROCESSING_TIME:
+ return getProcessingTime();
+
+ case QUEUE_TIME:
+ return getQueueTime();
+
+ case RESPONSE_SIZE:
+ return getResponseSize();
+
+ case CLIENT_ADDRESS:
+ return getClientAddress();
+
+ case SERVER_CLASS:
+ return getServerClass();
+
+ case METHOD_NAME:
+ return getMethodName();
+
+ case CALL_DETAILS:
+ return getCallDetails();
+
+ case PARAM:
+ return getParam();
+
+ case USER_NAME:
+ return getUserName();
+
+ case MULTI_GETS_COUNT:
+ return getMultiGetsCount();
+
+ case MULTI_MUTATIONS_COUNT:
+ return getMultiMutationsCount();
+
+ case MULTI_SERVICE_CALLS:
+ return getMultiServiceCalls();
+
+ case REGION_NAME:
+ return getRegionName();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case START_TIME:
+ return isSetStartTime();
+ case PROCESSING_TIME:
+ return isSetProcessingTime();
+ case QUEUE_TIME:
+ return isSetQueueTime();
+ case RESPONSE_SIZE:
+ return isSetResponseSize();
+ case CLIENT_ADDRESS:
+ return isSetClientAddress();
+ case SERVER_CLASS:
+ return isSetServerClass();
+ case METHOD_NAME:
+ return isSetMethodName();
+ case CALL_DETAILS:
+ return isSetCallDetails();
+ case PARAM:
+ return isSetParam();
+ case USER_NAME:
+ return isSetUserName();
+ case MULTI_GETS_COUNT:
+ return isSetMultiGetsCount();
+ case MULTI_MUTATIONS_COUNT:
+ return isSetMultiMutationsCount();
+ case MULTI_SERVICE_CALLS:
+ return isSetMultiServiceCalls();
+ case REGION_NAME:
+ return isSetRegionName();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TOnlineLogRecord)
+ return this.equals((TOnlineLogRecord)that);
+ return false;
+ }
+
+ public boolean equals(TOnlineLogRecord that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_startTime = true;
+ boolean that_present_startTime = true;
+ if (this_present_startTime || that_present_startTime) {
+ if (!(this_present_startTime && that_present_startTime))
+ return false;
+ if (this.startTime != that.startTime)
+ return false;
+ }
+
+ boolean this_present_processingTime = true;
+ boolean that_present_processingTime = true;
+ if (this_present_processingTime || that_present_processingTime) {
+ if (!(this_present_processingTime && that_present_processingTime))
+ return false;
+ if (this.processingTime != that.processingTime)
+ return false;
+ }
+
+ boolean this_present_queueTime = true;
+ boolean that_present_queueTime = true;
+ if (this_present_queueTime || that_present_queueTime) {
+ if (!(this_present_queueTime && that_present_queueTime))
+ return false;
+ if (this.queueTime != that.queueTime)
+ return false;
+ }
+
+ boolean this_present_responseSize = true;
+ boolean that_present_responseSize = true;
+ if (this_present_responseSize || that_present_responseSize) {
+ if (!(this_present_responseSize && that_present_responseSize))
+ return false;
+ if (this.responseSize != that.responseSize)
+ return false;
+ }
+
+ boolean this_present_clientAddress = true && this.isSetClientAddress();
+ boolean that_present_clientAddress = true && that.isSetClientAddress();
+ if (this_present_clientAddress || that_present_clientAddress) {
+ if (!(this_present_clientAddress && that_present_clientAddress))
+ return false;
+ if (!this.clientAddress.equals(that.clientAddress))
+ return false;
+ }
+
+ boolean this_present_serverClass = true && this.isSetServerClass();
+ boolean that_present_serverClass = true && that.isSetServerClass();
+ if (this_present_serverClass || that_present_serverClass) {
+ if (!(this_present_serverClass && that_present_serverClass))
+ return false;
+ if (!this.serverClass.equals(that.serverClass))
+ return false;
+ }
+
+ boolean this_present_methodName = true && this.isSetMethodName();
+ boolean that_present_methodName = true && that.isSetMethodName();
+ if (this_present_methodName || that_present_methodName) {
+ if (!(this_present_methodName && that_present_methodName))
+ return false;
+ if (!this.methodName.equals(that.methodName))
+ return false;
+ }
+
+ boolean this_present_callDetails = true && this.isSetCallDetails();
+ boolean that_present_callDetails = true && that.isSetCallDetails();
+ if (this_present_callDetails || that_present_callDetails) {
+ if (!(this_present_callDetails && that_present_callDetails))
+ return false;
+ if (!this.callDetails.equals(that.callDetails))
+ return false;
+ }
+
+ boolean this_present_param = true && this.isSetParam();
+ boolean that_present_param = true && that.isSetParam();
+ if (this_present_param || that_present_param) {
+ if (!(this_present_param && that_present_param))
+ return false;
+ if (!this.param.equals(that.param))
+ return false;
+ }
+
+ boolean this_present_userName = true && this.isSetUserName();
+ boolean that_present_userName = true && that.isSetUserName();
+ if (this_present_userName || that_present_userName) {
+ if (!(this_present_userName && that_present_userName))
+ return false;
+ if (!this.userName.equals(that.userName))
+ return false;
+ }
+
+ boolean this_present_multiGetsCount = true;
+ boolean that_present_multiGetsCount = true;
+ if (this_present_multiGetsCount || that_present_multiGetsCount) {
+ if (!(this_present_multiGetsCount && that_present_multiGetsCount))
+ return false;
+ if (this.multiGetsCount != that.multiGetsCount)
+ return false;
+ }
+
+ boolean this_present_multiMutationsCount = true;
+ boolean that_present_multiMutationsCount = true;
+ if (this_present_multiMutationsCount || that_present_multiMutationsCount) {
+ if (!(this_present_multiMutationsCount && that_present_multiMutationsCount))
+ return false;
+ if (this.multiMutationsCount != that.multiMutationsCount)
+ return false;
+ }
+
+ boolean this_present_multiServiceCalls = true;
+ boolean that_present_multiServiceCalls = true;
+ if (this_present_multiServiceCalls || that_present_multiServiceCalls) {
+ if (!(this_present_multiServiceCalls && that_present_multiServiceCalls))
+ return false;
+ if (this.multiServiceCalls != that.multiServiceCalls)
+ return false;
+ }
+
+ boolean this_present_regionName = true && this.isSetRegionName();
+ boolean that_present_regionName = true && that.isSetRegionName();
+ if (this_present_regionName || that_present_regionName) {
+ if (!(this_present_regionName && that_present_regionName))
+ return false;
+ if (!this.regionName.equals(that.regionName))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(startTime);
+
+ hashCode = hashCode * 8191 + processingTime;
+
+ hashCode = hashCode * 8191 + queueTime;
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(responseSize);
+
+ hashCode = hashCode * 8191 + ((isSetClientAddress()) ? 131071 : 524287);
+ if (isSetClientAddress())
+ hashCode = hashCode * 8191 + clientAddress.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetServerClass()) ? 131071 : 524287);
+ if (isSetServerClass())
+ hashCode = hashCode * 8191 + serverClass.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetMethodName()) ? 131071 : 524287);
+ if (isSetMethodName())
+ hashCode = hashCode * 8191 + methodName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetCallDetails()) ? 131071 : 524287);
+ if (isSetCallDetails())
+ hashCode = hashCode * 8191 + callDetails.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetParam()) ? 131071 : 524287);
+ if (isSetParam())
+ hashCode = hashCode * 8191 + param.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetUserName()) ? 131071 : 524287);
+ if (isSetUserName())
+ hashCode = hashCode * 8191 + userName.hashCode();
+
+ hashCode = hashCode * 8191 + multiGetsCount;
+
+ hashCode = hashCode * 8191 + multiMutationsCount;
+
+ hashCode = hashCode * 8191 + multiServiceCalls;
+
+ hashCode = hashCode * 8191 + ((isSetRegionName()) ? 131071 : 524287);
+ if (isSetRegionName())
+ hashCode = hashCode * 8191 + regionName.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TOnlineLogRecord other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetStartTime(), other.isSetStartTime());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartTime()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startTime, other.startTime);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetProcessingTime(), other.isSetProcessingTime());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetProcessingTime()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.processingTime, other.processingTime);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQueueTime(), other.isSetQueueTime());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQueueTime()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.queueTime, other.queueTime);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetResponseSize(), other.isSetResponseSize());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetResponseSize()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.responseSize, other.responseSize);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetClientAddress(), other.isSetClientAddress());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetClientAddress()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.clientAddress, other.clientAddress);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetServerClass(), other.isSetServerClass());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetServerClass()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverClass, other.serverClass);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMethodName(), other.isSetMethodName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMethodName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.methodName, other.methodName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCallDetails(), other.isSetCallDetails());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCallDetails()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.callDetails, other.callDetails);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetParam(), other.isSetParam());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetParam()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.param, other.param);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetUserName(), other.isSetUserName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetUserName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userName, other.userName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMultiGetsCount(), other.isSetMultiGetsCount());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMultiGetsCount()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.multiGetsCount, other.multiGetsCount);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMultiMutationsCount(), other.isSetMultiMutationsCount());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMultiMutationsCount()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.multiMutationsCount, other.multiMutationsCount);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMultiServiceCalls(), other.isSetMultiServiceCalls());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMultiServiceCalls()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.multiServiceCalls, other.multiServiceCalls);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetRegionName(), other.isSetRegionName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRegionName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.regionName, other.regionName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TOnlineLogRecord(");
+ boolean first = true;
+
+ sb.append("startTime:");
+ sb.append(this.startTime);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("processingTime:");
+ sb.append(this.processingTime);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("queueTime:");
+ sb.append(this.queueTime);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("responseSize:");
+ sb.append(this.responseSize);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("clientAddress:");
+ if (this.clientAddress == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.clientAddress);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("serverClass:");
+ if (this.serverClass == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.serverClass);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("methodName:");
+ if (this.methodName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.methodName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("callDetails:");
+ if (this.callDetails == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.callDetails);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("param:");
+ if (this.param == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.param);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("userName:");
+ if (this.userName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.userName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("multiGetsCount:");
+ sb.append(this.multiGetsCount);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("multiMutationsCount:");
+ sb.append(this.multiMutationsCount);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("multiServiceCalls:");
+ sb.append(this.multiServiceCalls);
+ first = false;
+ if (isSetRegionName()) {
+ if (!first) sb.append(", ");
+ sb.append("regionName:");
+ if (this.regionName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.regionName);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // alas, we cannot check 'startTime' because it's a primitive and you chose the non-beans generator.
+ // alas, we cannot check 'processingTime' because it's a primitive and you chose the non-beans generator.
+ // alas, we cannot check 'queueTime' because it's a primitive and you chose the non-beans generator.
+ // alas, we cannot check 'responseSize' because it's a primitive and you chose the non-beans generator.
+ if (clientAddress == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'clientAddress' was not present! Struct: " + toString());
+ }
+ if (serverClass == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'serverClass' was not present! Struct: " + toString());
+ }
+ if (methodName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'methodName' was not present! Struct: " + toString());
+ }
+ if (callDetails == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'callDetails' was not present! Struct: " + toString());
+ }
+ if (param == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'param' was not present! Struct: " + toString());
+ }
+ if (userName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'userName' was not present! Struct: " + toString());
+ }
+ // alas, we cannot check 'multiGetsCount' because it's a primitive and you chose the non-beans generator.
+ // alas, we cannot check 'multiMutationsCount' because it's a primitive and you chose the non-beans generator.
+ // alas, we cannot check 'multiServiceCalls' because it's a primitive and you chose the non-beans generator.
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TOnlineLogRecordStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TOnlineLogRecordStandardScheme getScheme() {
+ return new TOnlineLogRecordStandardScheme();
+ }
+ }
+
+ private static class TOnlineLogRecordStandardScheme extends org.apache.thrift.scheme.StandardScheme<TOnlineLogRecord> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TOnlineLogRecord struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // START_TIME
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.startTime = iprot.readI64();
+ struct.setStartTimeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // PROCESSING_TIME
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.processingTime = iprot.readI32();
+ struct.setProcessingTimeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // QUEUE_TIME
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.queueTime = iprot.readI32();
+ struct.setQueueTimeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // RESPONSE_SIZE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.responseSize = iprot.readI64();
+ struct.setResponseSizeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // CLIENT_ADDRESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.clientAddress = iprot.readString();
+ struct.setClientAddressIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // SERVER_CLASS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.serverClass = iprot.readString();
+ struct.setServerClassIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // METHOD_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.methodName = iprot.readString();
+ struct.setMethodNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 8: // CALL_DETAILS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.callDetails = iprot.readString();
+ struct.setCallDetailsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 9: // PARAM
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.param = iprot.readString();
+ struct.setParamIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 10: // USER_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.userName = iprot.readString();
+ struct.setUserNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 11: // MULTI_GETS_COUNT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.multiGetsCount = iprot.readI32();
+ struct.setMultiGetsCountIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 12: // MULTI_MUTATIONS_COUNT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.multiMutationsCount = iprot.readI32();
+ struct.setMultiMutationsCountIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 13: // MULTI_SERVICE_CALLS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.multiServiceCalls = iprot.readI32();
+ struct.setMultiServiceCallsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 14: // REGION_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.regionName = iprot.readString();
+ struct.setRegionNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetStartTime()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'startTime' was not found in serialized data! Struct: " + toString());
+ }
+ if (!struct.isSetProcessingTime()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'processingTime' was not found in serialized data! Struct: " + toString());
+ }
+ if (!struct.isSetQueueTime()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'queueTime' was not found in serialized data! Struct: " + toString());
+ }
+ if (!struct.isSetResponseSize()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'responseSize' was not found in serialized data! Struct: " + toString());
+ }
+ if (!struct.isSetMultiGetsCount()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'multiGetsCount' was not found in serialized data! Struct: " + toString());
+ }
+ if (!struct.isSetMultiMutationsCount()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'multiMutationsCount' was not found in serialized data! Struct: " + toString());
+ }
+ if (!struct.isSetMultiServiceCalls()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'multiServiceCalls' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TOnlineLogRecord struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(START_TIME_FIELD_DESC);
+ oprot.writeI64(struct.startTime);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(PROCESSING_TIME_FIELD_DESC);
+ oprot.writeI32(struct.processingTime);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(QUEUE_TIME_FIELD_DESC);
+ oprot.writeI32(struct.queueTime);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(RESPONSE_SIZE_FIELD_DESC);
+ oprot.writeI64(struct.responseSize);
+ oprot.writeFieldEnd();
+ if (struct.clientAddress != null) {
+ oprot.writeFieldBegin(CLIENT_ADDRESS_FIELD_DESC);
+ oprot.writeString(struct.clientAddress);
+ oprot.writeFieldEnd();
+ }
+ if (struct.serverClass != null) {
+ oprot.writeFieldBegin(SERVER_CLASS_FIELD_DESC);
+ oprot.writeString(struct.serverClass);
+ oprot.writeFieldEnd();
+ }
+ if (struct.methodName != null) {
+ oprot.writeFieldBegin(METHOD_NAME_FIELD_DESC);
+ oprot.writeString(struct.methodName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.callDetails != null) {
+ oprot.writeFieldBegin(CALL_DETAILS_FIELD_DESC);
+ oprot.writeString(struct.callDetails);
+ oprot.writeFieldEnd();
+ }
+ if (struct.param != null) {
+ oprot.writeFieldBegin(PARAM_FIELD_DESC);
+ oprot.writeString(struct.param);
+ oprot.writeFieldEnd();
+ }
+ if (struct.userName != null) {
+ oprot.writeFieldBegin(USER_NAME_FIELD_DESC);
+ oprot.writeString(struct.userName);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldBegin(MULTI_GETS_COUNT_FIELD_DESC);
+ oprot.writeI32(struct.multiGetsCount);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(MULTI_MUTATIONS_COUNT_FIELD_DESC);
+ oprot.writeI32(struct.multiMutationsCount);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(MULTI_SERVICE_CALLS_FIELD_DESC);
+ oprot.writeI32(struct.multiServiceCalls);
+ oprot.writeFieldEnd();
+ if (struct.regionName != null) {
+ if (struct.isSetRegionName()) {
+ oprot.writeFieldBegin(REGION_NAME_FIELD_DESC);
+ oprot.writeString(struct.regionName);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TOnlineLogRecordTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TOnlineLogRecordTupleScheme getScheme() {
+ return new TOnlineLogRecordTupleScheme();
+ }
+ }
+
+ private static class TOnlineLogRecordTupleScheme extends org.apache.thrift.scheme.TupleScheme<TOnlineLogRecord> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TOnlineLogRecord struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeI64(struct.startTime);
+ oprot.writeI32(struct.processingTime);
+ oprot.writeI32(struct.queueTime);
+ oprot.writeI64(struct.responseSize);
+ oprot.writeString(struct.clientAddress);
+ oprot.writeString(struct.serverClass);
+ oprot.writeString(struct.methodName);
+ oprot.writeString(struct.callDetails);
+ oprot.writeString(struct.param);
+ oprot.writeString(struct.userName);
+ oprot.writeI32(struct.multiGetsCount);
+ oprot.writeI32(struct.multiMutationsCount);
+ oprot.writeI32(struct.multiServiceCalls);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRegionName()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetRegionName()) {
+ oprot.writeString(struct.regionName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TOnlineLogRecord struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.startTime = iprot.readI64();
+ struct.setStartTimeIsSet(true);
+ struct.processingTime = iprot.readI32();
+ struct.setProcessingTimeIsSet(true);
+ struct.queueTime = iprot.readI32();
+ struct.setQueueTimeIsSet(true);
+ struct.responseSize = iprot.readI64();
+ struct.setResponseSizeIsSet(true);
+ struct.clientAddress = iprot.readString();
+ struct.setClientAddressIsSet(true);
+ struct.serverClass = iprot.readString();
+ struct.setServerClassIsSet(true);
+ struct.methodName = iprot.readString();
+ struct.setMethodNameIsSet(true);
+ struct.callDetails = iprot.readString();
+ struct.setCallDetailsIsSet(true);
+ struct.param = iprot.readString();
+ struct.setParamIsSet(true);
+ struct.userName = iprot.readString();
+ struct.setUserNameIsSet(true);
+ struct.multiGetsCount = iprot.readI32();
+ struct.setMultiGetsCountIsSet(true);
+ struct.multiMutationsCount = iprot.readI32();
+ struct.setMultiMutationsCountIsSet(true);
+ struct.multiServiceCalls = iprot.readI32();
+ struct.setMultiServiceCallsIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.regionName = iprot.readString();
+ struct.setRegionNameIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TPermissionScope.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TPermissionScope.java
new file mode 100644
index 0000000..7ca83ce
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TPermissionScope.java
@@ -0,0 +1,43 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TPermissionScope implements org.apache.thrift.TEnum {
+ TABLE(0),
+ NAMESPACE(1);
+
+ private final int value;
+
+ private TPermissionScope(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TPermissionScope findByValue(int value) {
+ switch (value) {
+ case 0:
+ return TABLE;
+ case 1:
+ return NAMESPACE;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TPut.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TPut.java
new file mode 100644
index 0000000..b458182
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TPut.java
@@ -0,0 +1,1050 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Used to perform Put operations for a single row.
+ *
+ * Add column values to this object and they'll be added.
+ * You can provide a default timestamp if the column values
+ * don't have one. If you don't provide a default timestamp
+ * the current time is inserted.
+ *
+ * You can specify how this Put should be written to the write-ahead Log (WAL)
+ * by changing the durability. If you don't provide durability, it defaults to
+ * column family's default setting for durability.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TPut implements org.apache.thrift.TBase<TPut, TPut._Fields>, java.io.Serializable, Cloneable, Comparable<TPut> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TPut");
+
+ 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)1);
+ private static final org.apache.thrift.protocol.TField COLUMN_VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("columnValues", 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 org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)5);
+ private static final org.apache.thrift.protocol.TField DURABILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("durability", org.apache.thrift.protocol.TType.I32, (short)6);
+ private static final org.apache.thrift.protocol.TField CELL_VISIBILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("cellVisibility", org.apache.thrift.protocol.TType.STRUCT, (short)7);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TPutStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TPutTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumnValue> columnValues; // required
+ public long timestamp; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ /**
+ *
+ * @see TDurability
+ */
+ public @org.apache.thrift.annotation.Nullable TDurability durability; // optional
+ public @org.apache.thrift.annotation.Nullable TCellVisibility cellVisibility; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ COLUMN_VALUES((short)2, "columnValues"),
+ TIMESTAMP((short)3, "timestamp"),
+ ATTRIBUTES((short)5, "attributes"),
+ /**
+ *
+ * @see TDurability
+ */
+ DURABILITY((short)6, "durability"),
+ CELL_VISIBILITY((short)7, "cellVisibility");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // COLUMN_VALUES
+ return COLUMN_VALUES;
+ case 3: // TIMESTAMP
+ return TIMESTAMP;
+ case 5: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 6: // DURABILITY
+ return DURABILITY;
+ case 7: // CELL_VISIBILITY
+ return CELL_VISIBILITY;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TIMESTAMP_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.TIMESTAMP,_Fields.ATTRIBUTES,_Fields.DURABILITY,_Fields.CELL_VISIBILITY};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.COLUMN_VALUES, new org.apache.thrift.meta_data.FieldMetaData("columnValues", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TColumnValue.class))));
+ 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.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.DURABILITY, new org.apache.thrift.meta_data.FieldMetaData("durability", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDurability.class)));
+ tmpMap.put(_Fields.CELL_VISIBILITY, new org.apache.thrift.meta_data.FieldMetaData("cellVisibility", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCellVisibility.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TPut.class, metaDataMap);
+ }
+
+ public TPut() {
+ }
+
+ public TPut(
+ java.nio.ByteBuffer row,
+ java.util.List<TColumnValue> columnValues)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.columnValues = columnValues;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TPut(TPut other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumnValues()) {
+ java.util.List<TColumnValue> __this__columnValues = new java.util.ArrayList<TColumnValue>(other.columnValues.size());
+ for (TColumnValue other_element : other.columnValues) {
+ __this__columnValues.add(new TColumnValue(other_element));
+ }
+ this.columnValues = __this__columnValues;
+ }
+ this.timestamp = other.timestamp;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetDurability()) {
+ this.durability = other.durability;
+ }
+ if (other.isSetCellVisibility()) {
+ this.cellVisibility = new TCellVisibility(other.cellVisibility);
+ }
+ }
+
+ public TPut deepCopy() {
+ return new TPut(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.columnValues = null;
+ setTimestampIsSet(false);
+ this.timestamp = 0;
+ this.attributes = null;
+ this.durability = null;
+ this.cellVisibility = null;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TPut setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TPut setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnValuesSize() {
+ return (this.columnValues == null) ? 0 : this.columnValues.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumnValue> getColumnValuesIterator() {
+ return (this.columnValues == null) ? null : this.columnValues.iterator();
+ }
+
+ public void addToColumnValues(TColumnValue elem) {
+ if (this.columnValues == null) {
+ this.columnValues = new java.util.ArrayList<TColumnValue>();
+ }
+ this.columnValues.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumnValue> getColumnValues() {
+ return this.columnValues;
+ }
+
+ public TPut setColumnValues(@org.apache.thrift.annotation.Nullable java.util.List<TColumnValue> columnValues) {
+ this.columnValues = columnValues;
+ return this;
+ }
+
+ public void unsetColumnValues() {
+ this.columnValues = null;
+ }
+
+ /** Returns true if field columnValues is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumnValues() {
+ return this.columnValues != null;
+ }
+
+ public void setColumnValuesIsSet(boolean value) {
+ if (!value) {
+ this.columnValues = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public TPut setTimestamp(long timestamp) {
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ return this;
+ }
+
+ public void unsetTimestamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimestamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
+ }
+
+ public void setTimestampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TPut setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDurability getDurability() {
+ return this.durability;
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ public TPut setDurability(@org.apache.thrift.annotation.Nullable TDurability durability) {
+ this.durability = durability;
+ return this;
+ }
+
+ public void unsetDurability() {
+ this.durability = null;
+ }
+
+ /** Returns true if field durability is set (has been assigned a value) and false otherwise */
+ public boolean isSetDurability() {
+ return this.durability != null;
+ }
+
+ public void setDurabilityIsSet(boolean value) {
+ if (!value) {
+ this.durability = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TCellVisibility getCellVisibility() {
+ return this.cellVisibility;
+ }
+
+ public TPut setCellVisibility(@org.apache.thrift.annotation.Nullable TCellVisibility cellVisibility) {
+ this.cellVisibility = cellVisibility;
+ return this;
+ }
+
+ public void unsetCellVisibility() {
+ this.cellVisibility = null;
+ }
+
+ /** Returns true if field cellVisibility is set (has been assigned a value) and false otherwise */
+ public boolean isSetCellVisibility() {
+ return this.cellVisibility != null;
+ }
+
+ public void setCellVisibilityIsSet(boolean value) {
+ if (!value) {
+ this.cellVisibility = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN_VALUES:
+ if (value == null) {
+ unsetColumnValues();
+ } else {
+ setColumnValues((java.util.List<TColumnValue>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((java.lang.Long)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case DURABILITY:
+ if (value == null) {
+ unsetDurability();
+ } else {
+ setDurability((TDurability)value);
+ }
+ break;
+
+ case CELL_VISIBILITY:
+ if (value == null) {
+ unsetCellVisibility();
+ } else {
+ setCellVisibility((TCellVisibility)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case COLUMN_VALUES:
+ return getColumnValues();
+
+ case TIMESTAMP:
+ return getTimestamp();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case DURABILITY:
+ return getDurability();
+
+ case CELL_VISIBILITY:
+ return getCellVisibility();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case COLUMN_VALUES:
+ return isSetColumnValues();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case DURABILITY:
+ return isSetDurability();
+ case CELL_VISIBILITY:
+ return isSetCellVisibility();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TPut)
+ return this.equals((TPut)that);
+ return false;
+ }
+
+ public boolean equals(TPut that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columnValues = true && this.isSetColumnValues();
+ boolean that_present_columnValues = true && that.isSetColumnValues();
+ if (this_present_columnValues || that_present_columnValues) {
+ if (!(this_present_columnValues && that_present_columnValues))
+ return false;
+ if (!this.columnValues.equals(that.columnValues))
+ return false;
+ }
+
+ boolean this_present_timestamp = true && this.isSetTimestamp();
+ boolean that_present_timestamp = true && that.isSetTimestamp();
+ if (this_present_timestamp || that_present_timestamp) {
+ if (!(this_present_timestamp && that_present_timestamp))
+ return false;
+ if (this.timestamp != that.timestamp)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_durability = true && this.isSetDurability();
+ boolean that_present_durability = true && that.isSetDurability();
+ if (this_present_durability || that_present_durability) {
+ if (!(this_present_durability && that_present_durability))
+ return false;
+ if (!this.durability.equals(that.durability))
+ return false;
+ }
+
+ boolean this_present_cellVisibility = true && this.isSetCellVisibility();
+ boolean that_present_cellVisibility = true && that.isSetCellVisibility();
+ if (this_present_cellVisibility || that_present_cellVisibility) {
+ if (!(this_present_cellVisibility && that_present_cellVisibility))
+ return false;
+ if (!this.cellVisibility.equals(that.cellVisibility))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumnValues()) ? 131071 : 524287);
+ if (isSetColumnValues())
+ hashCode = hashCode * 8191 + columnValues.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetTimestamp()) ? 131071 : 524287);
+ if (isSetTimestamp())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(timestamp);
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetDurability()) ? 131071 : 524287);
+ if (isSetDurability())
+ hashCode = hashCode * 8191 + durability.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetCellVisibility()) ? 131071 : 524287);
+ if (isSetCellVisibility())
+ hashCode = hashCode * 8191 + cellVisibility.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TPut other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumnValues(), other.isSetColumnValues());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumnValues()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columnValues, other.columnValues);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimestamp(), other.isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimestamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, other.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDurability(), other.isSetDurability());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDurability()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.durability, other.durability);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCellVisibility(), other.isSetCellVisibility());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCellVisibility()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cellVisibility, other.cellVisibility);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TPut(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("columnValues:");
+ if (this.columnValues == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columnValues);
+ }
+ first = false;
+ if (isSetTimestamp()) {
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ }
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetDurability()) {
+ if (!first) sb.append(", ");
+ sb.append("durability:");
+ if (this.durability == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.durability);
+ }
+ first = false;
+ }
+ if (isSetCellVisibility()) {
+ if (!first) sb.append(", ");
+ sb.append("cellVisibility:");
+ if (this.cellVisibility == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.cellVisibility);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ if (columnValues == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'columnValues' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (cellVisibility != null) {
+ cellVisibility.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TPutStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TPutStandardScheme getScheme() {
+ return new TPutStandardScheme();
+ }
+ }
+
+ private static class TPutStandardScheme extends org.apache.thrift.scheme.StandardScheme<TPut> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TPut struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMN_VALUES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list34 = iprot.readListBegin();
+ struct.columnValues = new java.util.ArrayList<TColumnValue>(_list34.size);
+ @org.apache.thrift.annotation.Nullable TColumnValue _elem35;
+ for (int _i36 = 0; _i36 < _list34.size; ++_i36)
+ {
+ _elem35 = new TColumnValue();
+ _elem35.read(iprot);
+ struct.columnValues.add(_elem35);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnValuesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TIMESTAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map37 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map37.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key38;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val39;
+ for (int _i40 = 0; _i40 < _map37.size; ++_i40)
+ {
+ _key38 = iprot.readBinary();
+ _val39 = iprot.readBinary();
+ struct.attributes.put(_key38, _val39);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // DURABILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // CELL_VISIBILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.cellVisibility = new TCellVisibility();
+ struct.cellVisibility.read(iprot);
+ struct.setCellVisibilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TPut struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columnValues != null) {
+ oprot.writeFieldBegin(COLUMN_VALUES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columnValues.size()));
+ for (TColumnValue _iter41 : struct.columnValues)
+ {
+ _iter41.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetTimestamp()) {
+ oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
+ oprot.writeI64(struct.timestamp);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter42 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter42.getKey());
+ oprot.writeBinary(_iter42.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.durability != null) {
+ if (struct.isSetDurability()) {
+ oprot.writeFieldBegin(DURABILITY_FIELD_DESC);
+ oprot.writeI32(struct.durability.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.cellVisibility != null) {
+ if (struct.isSetCellVisibility()) {
+ oprot.writeFieldBegin(CELL_VISIBILITY_FIELD_DESC);
+ struct.cellVisibility.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TPutTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TPutTupleScheme getScheme() {
+ return new TPutTupleScheme();
+ }
+ }
+
+ private static class TPutTupleScheme extends org.apache.thrift.scheme.TupleScheme<TPut> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TPut struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.row);
+ {
+ oprot.writeI32(struct.columnValues.size());
+ for (TColumnValue _iter43 : struct.columnValues)
+ {
+ _iter43.write(oprot);
+ }
+ }
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetTimestamp()) {
+ optionals.set(0);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(1);
+ }
+ if (struct.isSetDurability()) {
+ optionals.set(2);
+ }
+ if (struct.isSetCellVisibility()) {
+ optionals.set(3);
+ }
+ oprot.writeBitSet(optionals, 4);
+ if (struct.isSetTimestamp()) {
+ oprot.writeI64(struct.timestamp);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter44 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter44.getKey());
+ oprot.writeBinary(_iter44.getValue());
+ }
+ }
+ }
+ if (struct.isSetDurability()) {
+ oprot.writeI32(struct.durability.getValue());
+ }
+ if (struct.isSetCellVisibility()) {
+ struct.cellVisibility.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TPut struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list45 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columnValues = new java.util.ArrayList<TColumnValue>(_list45.size);
+ @org.apache.thrift.annotation.Nullable TColumnValue _elem46;
+ for (int _i47 = 0; _i47 < _list45.size; ++_i47)
+ {
+ _elem46 = new TColumnValue();
+ _elem46.read(iprot);
+ struct.columnValues.add(_elem46);
+ }
+ }
+ struct.setColumnValuesIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(4);
+ if (incoming.get(0)) {
+ struct.timestamp = iprot.readI64();
+ struct.setTimestampIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TMap _map48 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map48.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key49;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val50;
+ for (int _i51 = 0; _i51 < _map48.size; ++_i51)
+ {
+ _key49 = iprot.readBinary();
+ _val50 = iprot.readBinary();
+ struct.attributes.put(_key49, _val50);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.cellVisibility = new TCellVisibility();
+ struct.cellVisibility.read(iprot);
+ struct.setCellVisibilityIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TReadType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TReadType.java
new file mode 100644
index 0000000..8af01cd
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TReadType.java
@@ -0,0 +1,46 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TReadType implements org.apache.thrift.TEnum {
+ DEFAULT(1),
+ STREAM(2),
+ PREAD(3);
+
+ private final int value;
+
+ private TReadType(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TReadType findByValue(int value) {
+ switch (value) {
+ case 1:
+ return DEFAULT;
+ case 2:
+ return STREAM;
+ case 3:
+ return PREAD;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TResult.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TResult.java
new file mode 100644
index 0000000..757856e
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TResult.java
@@ -0,0 +1,756 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * if no Result is found, row and columnValues will not be set.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TResult implements org.apache.thrift.TBase<TResult, TResult._Fields>, java.io.Serializable, Cloneable, Comparable<TResult> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TResult");
+
+ 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)1);
+ private static final org.apache.thrift.protocol.TField COLUMN_VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("columnValues", org.apache.thrift.protocol.TType.LIST, (short)2);
+ private static final org.apache.thrift.protocol.TField STALE_FIELD_DESC = new org.apache.thrift.protocol.TField("stale", org.apache.thrift.protocol.TType.BOOL, (short)3);
+ private static final org.apache.thrift.protocol.TField PARTIAL_FIELD_DESC = new org.apache.thrift.protocol.TField("partial", org.apache.thrift.protocol.TType.BOOL, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TResultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TResultTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumnValue> columnValues; // required
+ public boolean stale; // optional
+ public boolean partial; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ COLUMN_VALUES((short)2, "columnValues"),
+ STALE((short)3, "stale"),
+ PARTIAL((short)4, "partial");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // COLUMN_VALUES
+ return COLUMN_VALUES;
+ case 3: // STALE
+ return STALE;
+ case 4: // PARTIAL
+ return PARTIAL;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __STALE_ISSET_ID = 0;
+ private static final int __PARTIAL_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.ROW,_Fields.STALE,_Fields.PARTIAL};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.COLUMN_VALUES, new org.apache.thrift.meta_data.FieldMetaData("columnValues", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TColumnValue.class))));
+ tmpMap.put(_Fields.STALE, new org.apache.thrift.meta_data.FieldMetaData("stale", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.PARTIAL, new org.apache.thrift.meta_data.FieldMetaData("partial", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TResult.class, metaDataMap);
+ }
+
+ public TResult() {
+ this.stale = false;
+
+ this.partial = false;
+
+ }
+
+ public TResult(
+ java.util.List<TColumnValue> columnValues)
+ {
+ this();
+ this.columnValues = columnValues;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TResult(TResult other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetColumnValues()) {
+ java.util.List<TColumnValue> __this__columnValues = new java.util.ArrayList<TColumnValue>(other.columnValues.size());
+ for (TColumnValue other_element : other.columnValues) {
+ __this__columnValues.add(new TColumnValue(other_element));
+ }
+ this.columnValues = __this__columnValues;
+ }
+ this.stale = other.stale;
+ this.partial = other.partial;
+ }
+
+ public TResult deepCopy() {
+ return new TResult(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.columnValues = null;
+ this.stale = false;
+
+ this.partial = false;
+
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TResult setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TResult setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getColumnValuesSize() {
+ return (this.columnValues == null) ? 0 : this.columnValues.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumnValue> getColumnValuesIterator() {
+ return (this.columnValues == null) ? null : this.columnValues.iterator();
+ }
+
+ public void addToColumnValues(TColumnValue elem) {
+ if (this.columnValues == null) {
+ this.columnValues = new java.util.ArrayList<TColumnValue>();
+ }
+ this.columnValues.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumnValue> getColumnValues() {
+ return this.columnValues;
+ }
+
+ public TResult setColumnValues(@org.apache.thrift.annotation.Nullable java.util.List<TColumnValue> columnValues) {
+ this.columnValues = columnValues;
+ return this;
+ }
+
+ public void unsetColumnValues() {
+ this.columnValues = null;
+ }
+
+ /** Returns true if field columnValues is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumnValues() {
+ return this.columnValues != null;
+ }
+
+ public void setColumnValuesIsSet(boolean value) {
+ if (!value) {
+ this.columnValues = null;
+ }
+ }
+
+ public boolean isStale() {
+ return this.stale;
+ }
+
+ public TResult setStale(boolean stale) {
+ this.stale = stale;
+ setStaleIsSet(true);
+ return this;
+ }
+
+ public void unsetStale() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __STALE_ISSET_ID);
+ }
+
+ /** Returns true if field stale is set (has been assigned a value) and false otherwise */
+ public boolean isSetStale() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __STALE_ISSET_ID);
+ }
+
+ public void setStaleIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __STALE_ISSET_ID, value);
+ }
+
+ public boolean isPartial() {
+ return this.partial;
+ }
+
+ public TResult setPartial(boolean partial) {
+ this.partial = partial;
+ setPartialIsSet(true);
+ return this;
+ }
+
+ public void unsetPartial() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PARTIAL_ISSET_ID);
+ }
+
+ /** Returns true if field partial is set (has been assigned a value) and false otherwise */
+ public boolean isSetPartial() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PARTIAL_ISSET_ID);
+ }
+
+ public void setPartialIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PARTIAL_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMN_VALUES:
+ if (value == null) {
+ unsetColumnValues();
+ } else {
+ setColumnValues((java.util.List<TColumnValue>)value);
+ }
+ break;
+
+ case STALE:
+ if (value == null) {
+ unsetStale();
+ } else {
+ setStale((java.lang.Boolean)value);
+ }
+ break;
+
+ case PARTIAL:
+ if (value == null) {
+ unsetPartial();
+ } else {
+ setPartial((java.lang.Boolean)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case COLUMN_VALUES:
+ return getColumnValues();
+
+ case STALE:
+ return isStale();
+
+ case PARTIAL:
+ return isPartial();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case COLUMN_VALUES:
+ return isSetColumnValues();
+ case STALE:
+ return isSetStale();
+ case PARTIAL:
+ return isSetPartial();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TResult)
+ return this.equals((TResult)that);
+ return false;
+ }
+
+ public boolean equals(TResult that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_columnValues = true && this.isSetColumnValues();
+ boolean that_present_columnValues = true && that.isSetColumnValues();
+ if (this_present_columnValues || that_present_columnValues) {
+ if (!(this_present_columnValues && that_present_columnValues))
+ return false;
+ if (!this.columnValues.equals(that.columnValues))
+ return false;
+ }
+
+ boolean this_present_stale = true && this.isSetStale();
+ boolean that_present_stale = true && that.isSetStale();
+ if (this_present_stale || that_present_stale) {
+ if (!(this_present_stale && that_present_stale))
+ return false;
+ if (this.stale != that.stale)
+ return false;
+ }
+
+ boolean this_present_partial = true && this.isSetPartial();
+ boolean that_present_partial = true && that.isSetPartial();
+ if (this_present_partial || that_present_partial) {
+ if (!(this_present_partial && that_present_partial))
+ return false;
+ if (this.partial != that.partial)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumnValues()) ? 131071 : 524287);
+ if (isSetColumnValues())
+ hashCode = hashCode * 8191 + columnValues.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStale()) ? 131071 : 524287);
+ if (isSetStale())
+ hashCode = hashCode * 8191 + ((stale) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetPartial()) ? 131071 : 524287);
+ if (isSetPartial())
+ hashCode = hashCode * 8191 + ((partial) ? 131071 : 524287);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TResult other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumnValues(), other.isSetColumnValues());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumnValues()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columnValues, other.columnValues);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStale(), other.isSetStale());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStale()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stale, other.stale);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetPartial(), other.isSetPartial());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetPartial()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partial, other.partial);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TResult(");
+ boolean first = true;
+
+ if (isSetRow()) {
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ }
+ if (!first) sb.append(", ");
+ sb.append("columnValues:");
+ if (this.columnValues == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columnValues);
+ }
+ first = false;
+ if (isSetStale()) {
+ if (!first) sb.append(", ");
+ sb.append("stale:");
+ sb.append(this.stale);
+ first = false;
+ }
+ if (isSetPartial()) {
+ if (!first) sb.append(", ");
+ sb.append("partial:");
+ sb.append(this.partial);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (columnValues == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'columnValues' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TResultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TResultStandardScheme getScheme() {
+ return new TResultStandardScheme();
+ }
+ }
+
+ private static class TResultStandardScheme extends org.apache.thrift.scheme.StandardScheme<TResult> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TResult struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMN_VALUES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list0 = iprot.readListBegin();
+ struct.columnValues = new java.util.ArrayList<TColumnValue>(_list0.size);
+ @org.apache.thrift.annotation.Nullable TColumnValue _elem1;
+ for (int _i2 = 0; _i2 < _list0.size; ++_i2)
+ {
+ _elem1 = new TColumnValue();
+ _elem1.read(iprot);
+ struct.columnValues.add(_elem1);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnValuesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // STALE
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.stale = iprot.readBool();
+ struct.setStaleIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // PARTIAL
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.partial = iprot.readBool();
+ struct.setPartialIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TResult struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ if (struct.isSetRow()) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.columnValues != null) {
+ oprot.writeFieldBegin(COLUMN_VALUES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columnValues.size()));
+ for (TColumnValue _iter3 : struct.columnValues)
+ {
+ _iter3.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetStale()) {
+ oprot.writeFieldBegin(STALE_FIELD_DESC);
+ oprot.writeBool(struct.stale);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetPartial()) {
+ oprot.writeFieldBegin(PARTIAL_FIELD_DESC);
+ oprot.writeBool(struct.partial);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TResultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TResultTupleScheme getScheme() {
+ return new TResultTupleScheme();
+ }
+ }
+
+ private static class TResultTupleScheme extends org.apache.thrift.scheme.TupleScheme<TResult> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TResult struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ {
+ oprot.writeI32(struct.columnValues.size());
+ for (TColumnValue _iter4 : struct.columnValues)
+ {
+ _iter4.write(oprot);
+ }
+ }
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetRow()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStale()) {
+ optionals.set(1);
+ }
+ if (struct.isSetPartial()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetRow()) {
+ oprot.writeBinary(struct.row);
+ }
+ if (struct.isSetStale()) {
+ oprot.writeBool(struct.stale);
+ }
+ if (struct.isSetPartial()) {
+ oprot.writeBool(struct.partial);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TResult struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ {
+ org.apache.thrift.protocol.TList _list5 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columnValues = new java.util.ArrayList<TColumnValue>(_list5.size);
+ @org.apache.thrift.annotation.Nullable TColumnValue _elem6;
+ for (int _i7 = 0; _i7 < _list5.size; ++_i7)
+ {
+ _elem6 = new TColumnValue();
+ _elem6.read(iprot);
+ struct.columnValues.add(_elem6);
+ }
+ }
+ struct.setColumnValuesIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.stale = iprot.readBool();
+ struct.setStaleIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.partial = iprot.readBool();
+ struct.setPartialIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TRowMutations.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TRowMutations.java
new file mode 100644
index 0000000..6accf9d
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TRowMutations.java
@@ -0,0 +1,540 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * A TRowMutations object is used to apply a number of Mutations to a single row.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TRowMutations implements org.apache.thrift.TBase<TRowMutations, TRowMutations._Fields>, java.io.Serializable, Cloneable, Comparable<TRowMutations> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TRowMutations");
+
+ 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)1);
+ 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)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TRowMutationsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TRowMutationsTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<TMutation> mutations; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ ROW((short)1, "row"),
+ MUTATIONS((short)2, "mutations");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // ROW
+ return ROW;
+ case 2: // MUTATIONS
+ return MUTATIONS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("mutations", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ 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, TMutation.class))));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TRowMutations.class, metaDataMap);
+ }
+
+ public TRowMutations() {
+ }
+
+ public TRowMutations(
+ java.nio.ByteBuffer row,
+ java.util.List<TMutation> mutations)
+ {
+ this();
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ this.mutations = mutations;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TRowMutations(TRowMutations other) {
+ if (other.isSetRow()) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
+ }
+ if (other.isSetMutations()) {
+ java.util.List<TMutation> __this__mutations = new java.util.ArrayList<TMutation>(other.mutations.size());
+ for (TMutation other_element : other.mutations) {
+ __this__mutations.add(new TMutation(other_element));
+ }
+ this.mutations = __this__mutations;
+ }
+ }
+
+ public TRowMutations deepCopy() {
+ return new TRowMutations(this);
+ }
+
+ @Override
+ public void clear() {
+ this.row = null;
+ this.mutations = null;
+ }
+
+ public byte[] getRow() {
+ setRow(org.apache.thrift.TBaseHelper.rightSize(row));
+ return row == null ? null : row.array();
+ }
+
+ public java.nio.ByteBuffer bufferForRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(row);
+ }
+
+ public TRowMutations setRow(byte[] row) {
+ this.row = row == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(row.clone());
+ return this;
+ }
+
+ public TRowMutations setRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer row) {
+ this.row = org.apache.thrift.TBaseHelper.copyBinary(row);
+ return this;
+ }
+
+ public void unsetRow() {
+ this.row = null;
+ }
+
+ /** Returns true if field row is set (has been assigned a value) and false otherwise */
+ public boolean isSetRow() {
+ return this.row != null;
+ }
+
+ public void setRowIsSet(boolean value) {
+ if (!value) {
+ this.row = null;
+ }
+ }
+
+ public int getMutationsSize() {
+ return (this.mutations == null) ? 0 : this.mutations.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TMutation> getMutationsIterator() {
+ return (this.mutations == null) ? null : this.mutations.iterator();
+ }
+
+ public void addToMutations(TMutation elem) {
+ if (this.mutations == null) {
+ this.mutations = new java.util.ArrayList<TMutation>();
+ }
+ this.mutations.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TMutation> getMutations() {
+ return this.mutations;
+ }
+
+ public TRowMutations setMutations(@org.apache.thrift.annotation.Nullable java.util.List<TMutation> mutations) {
+ this.mutations = mutations;
+ return this;
+ }
+
+ public void unsetMutations() {
+ this.mutations = null;
+ }
+
+ /** Returns true if field mutations is set (has been assigned a value) and false otherwise */
+ public boolean isSetMutations() {
+ return this.mutations != null;
+ }
+
+ public void setMutationsIsSet(boolean value) {
+ if (!value) {
+ this.mutations = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case ROW:
+ if (value == null) {
+ unsetRow();
+ } else {
+ if (value instanceof byte[]) {
+ setRow((byte[])value);
+ } else {
+ setRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case MUTATIONS:
+ if (value == null) {
+ unsetMutations();
+ } else {
+ setMutations((java.util.List<TMutation>)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case ROW:
+ return getRow();
+
+ case MUTATIONS:
+ return getMutations();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case ROW:
+ return isSetRow();
+ case MUTATIONS:
+ return isSetMutations();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TRowMutations)
+ return this.equals((TRowMutations)that);
+ return false;
+ }
+
+ public boolean equals(TRowMutations that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_row = true && this.isSetRow();
+ boolean that_present_row = true && that.isSetRow();
+ if (this_present_row || that_present_row) {
+ if (!(this_present_row && that_present_row))
+ return false;
+ if (!this.row.equals(that.row))
+ return false;
+ }
+
+ boolean this_present_mutations = true && this.isSetMutations();
+ boolean that_present_mutations = true && that.isSetMutations();
+ if (this_present_mutations || that_present_mutations) {
+ if (!(this_present_mutations && that_present_mutations))
+ return false;
+ if (!this.mutations.equals(that.mutations))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287);
+ if (isSetRow())
+ hashCode = hashCode * 8191 + row.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetMutations()) ? 131071 : 524287);
+ if (isSetMutations())
+ hashCode = hashCode * 8191 + mutations.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TRowMutations other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetRow(), other.isSetRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMutations(), other.isSetMutations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMutations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mutations, other.mutations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TRowMutations(");
+ boolean first = true;
+
+ sb.append("row:");
+ if (this.row == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.row, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("mutations:");
+ if (this.mutations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.mutations);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (row == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
+ }
+ if (mutations == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'mutations' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TRowMutationsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TRowMutationsStandardScheme getScheme() {
+ return new TRowMutationsStandardScheme();
+ }
+ }
+
+ private static class TRowMutationsStandardScheme extends org.apache.thrift.scheme.StandardScheme<TRowMutations> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TRowMutations struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // MUTATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list134 = iprot.readListBegin();
+ struct.mutations = new java.util.ArrayList<TMutation>(_list134.size);
+ @org.apache.thrift.annotation.Nullable TMutation _elem135;
+ for (int _i136 = 0; _i136 < _list134.size; ++_i136)
+ {
+ _elem135 = new TMutation();
+ _elem135.read(iprot);
+ struct.mutations.add(_elem135);
+ }
+ iprot.readListEnd();
+ }
+ struct.setMutationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TRowMutations struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.row != null) {
+ oprot.writeFieldBegin(ROW_FIELD_DESC);
+ oprot.writeBinary(struct.row);
+ oprot.writeFieldEnd();
+ }
+ if (struct.mutations != null) {
+ oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.mutations.size()));
+ for (TMutation _iter137 : struct.mutations)
+ {
+ _iter137.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TRowMutationsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TRowMutationsTupleScheme getScheme() {
+ return new TRowMutationsTupleScheme();
+ }
+ }
+
+ private static class TRowMutationsTupleScheme extends org.apache.thrift.scheme.TupleScheme<TRowMutations> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TRowMutations struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.row);
+ {
+ oprot.writeI32(struct.mutations.size());
+ for (TMutation _iter138 : struct.mutations)
+ {
+ _iter138.write(oprot);
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TRowMutations struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.row = iprot.readBinary();
+ struct.setRowIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list139 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.mutations = new java.util.ArrayList<TMutation>(_list139.size);
+ @org.apache.thrift.annotation.Nullable TMutation _elem140;
+ for (int _i141 = 0; _i141 < _list139.size; ++_i141)
+ {
+ _elem140 = new TMutation();
+ _elem140.read(iprot);
+ struct.mutations.add(_elem140);
+ }
+ }
+ struct.setMutationsIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java
new file mode 100644
index 0000000..6cfae7e
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java
@@ -0,0 +1,2412 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Any timestamps in the columns are ignored but the colFamTimeRangeMap included, use timeRange to select by timestamp.
+ * Max versions defaults to 1.
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TScan implements org.apache.thrift.TBase<TScan, TScan._Fields>, java.io.Serializable, Cloneable, Comparable<TScan> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.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 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 CACHING_FIELD_DESC = new org.apache.thrift.protocol.TField("caching", org.apache.thrift.protocol.TType.I32, (short)4);
+ private static final org.apache.thrift.protocol.TField MAX_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("maxVersions", org.apache.thrift.protocol.TType.I32, (short)5);
+ private static final org.apache.thrift.protocol.TField TIME_RANGE_FIELD_DESC = new org.apache.thrift.protocol.TField("timeRange", org.apache.thrift.protocol.TType.STRUCT, (short)6);
+ private static final org.apache.thrift.protocol.TField FILTER_STRING_FIELD_DESC = new org.apache.thrift.protocol.TField("filterString", org.apache.thrift.protocol.TType.STRING, (short)7);
+ private static final org.apache.thrift.protocol.TField BATCH_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("batchSize", org.apache.thrift.protocol.TType.I32, (short)8);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)9);
+ private static final org.apache.thrift.protocol.TField AUTHORIZATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("authorizations", org.apache.thrift.protocol.TType.STRUCT, (short)10);
+ private static final org.apache.thrift.protocol.TField REVERSED_FIELD_DESC = new org.apache.thrift.protocol.TField("reversed", org.apache.thrift.protocol.TType.BOOL, (short)11);
+ private static final org.apache.thrift.protocol.TField CACHE_BLOCKS_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheBlocks", org.apache.thrift.protocol.TType.BOOL, (short)12);
+ private static final org.apache.thrift.protocol.TField COL_FAM_TIME_RANGE_MAP_FIELD_DESC = new org.apache.thrift.protocol.TField("colFamTimeRangeMap", org.apache.thrift.protocol.TType.MAP, (short)13);
+ private static final org.apache.thrift.protocol.TField READ_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("readType", org.apache.thrift.protocol.TType.I32, (short)14);
+ private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I32, (short)15);
+ private static final org.apache.thrift.protocol.TField CONSISTENCY_FIELD_DESC = new org.apache.thrift.protocol.TField("consistency", org.apache.thrift.protocol.TType.I32, (short)16);
+ private static final org.apache.thrift.protocol.TField TARGET_REPLICA_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("targetReplicaId", org.apache.thrift.protocol.TType.I32, (short)17);
+ private static final org.apache.thrift.protocol.TField FILTER_BYTES_FIELD_DESC = new org.apache.thrift.protocol.TField("filterBytes", org.apache.thrift.protocol.TType.STRING, (short)18);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TScanStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TScanTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns; // optional
+ public int caching; // optional
+ public int maxVersions; // optional
+ public @org.apache.thrift.annotation.Nullable TTimeRange timeRange; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString; // optional
+ public int batchSize; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ public @org.apache.thrift.annotation.Nullable TAuthorization authorizations; // optional
+ public boolean reversed; // optional
+ public boolean cacheBlocks; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,TTimeRange> colFamTimeRangeMap; // optional
+ /**
+ *
+ * @see TReadType
+ */
+ public @org.apache.thrift.annotation.Nullable TReadType readType; // optional
+ public int limit; // optional
+ /**
+ *
+ * @see TConsistency
+ */
+ public @org.apache.thrift.annotation.Nullable TConsistency consistency; // optional
+ public int targetReplicaId; // optional
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterBytes; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ START_ROW((short)1, "startRow"),
+ STOP_ROW((short)2, "stopRow"),
+ COLUMNS((short)3, "columns"),
+ CACHING((short)4, "caching"),
+ MAX_VERSIONS((short)5, "maxVersions"),
+ TIME_RANGE((short)6, "timeRange"),
+ FILTER_STRING((short)7, "filterString"),
+ BATCH_SIZE((short)8, "batchSize"),
+ ATTRIBUTES((short)9, "attributes"),
+ AUTHORIZATIONS((short)10, "authorizations"),
+ REVERSED((short)11, "reversed"),
+ CACHE_BLOCKS((short)12, "cacheBlocks"),
+ COL_FAM_TIME_RANGE_MAP((short)13, "colFamTimeRangeMap"),
+ /**
+ *
+ * @see TReadType
+ */
+ READ_TYPE((short)14, "readType"),
+ LIMIT((short)15, "limit"),
+ /**
+ *
+ * @see TConsistency
+ */
+ CONSISTENCY((short)16, "consistency"),
+ TARGET_REPLICA_ID((short)17, "targetReplicaId"),
+ FILTER_BYTES((short)18, "filterBytes");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // START_ROW
+ return START_ROW;
+ case 2: // STOP_ROW
+ return STOP_ROW;
+ case 3: // COLUMNS
+ return COLUMNS;
+ case 4: // CACHING
+ return CACHING;
+ case 5: // MAX_VERSIONS
+ return MAX_VERSIONS;
+ case 6: // TIME_RANGE
+ return TIME_RANGE;
+ case 7: // FILTER_STRING
+ return FILTER_STRING;
+ case 8: // BATCH_SIZE
+ return BATCH_SIZE;
+ case 9: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 10: // AUTHORIZATIONS
+ return AUTHORIZATIONS;
+ case 11: // REVERSED
+ return REVERSED;
+ case 12: // CACHE_BLOCKS
+ return CACHE_BLOCKS;
+ case 13: // COL_FAM_TIME_RANGE_MAP
+ return COL_FAM_TIME_RANGE_MAP;
+ case 14: // READ_TYPE
+ return READ_TYPE;
+ case 15: // LIMIT
+ return LIMIT;
+ case 16: // CONSISTENCY
+ return CONSISTENCY;
+ case 17: // TARGET_REPLICA_ID
+ return TARGET_REPLICA_ID;
+ case 18: // FILTER_BYTES
+ return FILTER_BYTES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __CACHING_ISSET_ID = 0;
+ private static final int __MAXVERSIONS_ISSET_ID = 1;
+ private static final int __BATCHSIZE_ISSET_ID = 2;
+ private static final int __REVERSED_ISSET_ID = 3;
+ private static final int __CACHEBLOCKS_ISSET_ID = 4;
+ private static final int __LIMIT_ISSET_ID = 5;
+ private static final int __TARGETREPLICAID_ISSET_ID = 6;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.START_ROW,_Fields.STOP_ROW,_Fields.COLUMNS,_Fields.CACHING,_Fields.MAX_VERSIONS,_Fields.TIME_RANGE,_Fields.FILTER_STRING,_Fields.BATCH_SIZE,_Fields.ATTRIBUTES,_Fields.AUTHORIZATIONS,_Fields.REVERSED,_Fields.CACHE_BLOCKS,_Fields.COL_FAM_TIME_RANGE_MAP,_Fields.READ_TYPE,_Fields.LIMIT,_Fields.CONSISTENCY,_Fields.TARGET_REPLICA_ID,_Fields.FILTER_BYTES};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.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 , true)));
+ 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 , true)));
+ 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumn.class))));
+ 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)));
+ tmpMap.put(_Fields.MAX_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("maxVersions", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.TIME_RANGE, new org.apache.thrift.meta_data.FieldMetaData("timeRange", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTimeRange.class)));
+ tmpMap.put(_Fields.FILTER_STRING, new org.apache.thrift.meta_data.FieldMetaData("filterString", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.BATCH_SIZE, new org.apache.thrift.meta_data.FieldMetaData("batchSize", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.AUTHORIZATIONS, new org.apache.thrift.meta_data.FieldMetaData("authorizations", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAuthorization.class)));
+ tmpMap.put(_Fields.REVERSED, new org.apache.thrift.meta_data.FieldMetaData("reversed", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.CACHE_BLOCKS, new org.apache.thrift.meta_data.FieldMetaData("cacheBlocks", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+ tmpMap.put(_Fields.COL_FAM_TIME_RANGE_MAP, new org.apache.thrift.meta_data.FieldMetaData("colFamTimeRangeMap", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTimeRange.class))));
+ tmpMap.put(_Fields.READ_TYPE, new org.apache.thrift.meta_data.FieldMetaData("readType", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TReadType.class)));
+ tmpMap.put(_Fields.LIMIT, new org.apache.thrift.meta_data.FieldMetaData("limit", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.CONSISTENCY, new org.apache.thrift.meta_data.FieldMetaData("consistency", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TConsistency.class)));
+ tmpMap.put(_Fields.TARGET_REPLICA_ID, new org.apache.thrift.meta_data.FieldMetaData("targetReplicaId", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.FILTER_BYTES, new org.apache.thrift.meta_data.FieldMetaData("filterBytes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TScan.class, metaDataMap);
+ }
+
+ public TScan() {
+ this.maxVersions = 1;
+
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TScan(TScan other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetStartRow()) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
+ }
+ if (other.isSetStopRow()) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(other.stopRow);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<TColumn> __this__columns = new java.util.ArrayList<TColumn>(other.columns.size());
+ for (TColumn other_element : other.columns) {
+ __this__columns.add(new TColumn(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ this.caching = other.caching;
+ this.maxVersions = other.maxVersions;
+ if (other.isSetTimeRange()) {
+ this.timeRange = new TTimeRange(other.timeRange);
+ }
+ if (other.isSetFilterString()) {
+ this.filterString = org.apache.thrift.TBaseHelper.copyBinary(other.filterString);
+ }
+ this.batchSize = other.batchSize;
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetAuthorizations()) {
+ this.authorizations = new TAuthorization(other.authorizations);
+ }
+ this.reversed = other.reversed;
+ this.cacheBlocks = other.cacheBlocks;
+ if (other.isSetColFamTimeRangeMap()) {
+ java.util.Map<java.nio.ByteBuffer,TTimeRange> __this__colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>(other.colFamTimeRangeMap.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, TTimeRange> other_element : other.colFamTimeRangeMap.entrySet()) {
+
+ java.nio.ByteBuffer other_element_key = other_element.getKey();
+ TTimeRange other_element_value = other_element.getValue();
+
+ java.nio.ByteBuffer __this__colFamTimeRangeMap_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);
+
+ TTimeRange __this__colFamTimeRangeMap_copy_value = new TTimeRange(other_element_value);
+
+ __this__colFamTimeRangeMap.put(__this__colFamTimeRangeMap_copy_key, __this__colFamTimeRangeMap_copy_value);
+ }
+ this.colFamTimeRangeMap = __this__colFamTimeRangeMap;
+ }
+ if (other.isSetReadType()) {
+ this.readType = other.readType;
+ }
+ this.limit = other.limit;
+ if (other.isSetConsistency()) {
+ this.consistency = other.consistency;
+ }
+ this.targetReplicaId = other.targetReplicaId;
+ if (other.isSetFilterBytes()) {
+ this.filterBytes = org.apache.thrift.TBaseHelper.copyBinary(other.filterBytes);
+ }
+ }
+
+ public TScan deepCopy() {
+ return new TScan(this);
+ }
+
+ @Override
+ public void clear() {
+ this.startRow = null;
+ this.stopRow = null;
+ this.columns = null;
+ setCachingIsSet(false);
+ this.caching = 0;
+ this.maxVersions = 1;
+
+ this.timeRange = null;
+ this.filterString = null;
+ setBatchSizeIsSet(false);
+ this.batchSize = 0;
+ this.attributes = null;
+ this.authorizations = null;
+ setReversedIsSet(false);
+ this.reversed = false;
+ setCacheBlocksIsSet(false);
+ this.cacheBlocks = false;
+ this.colFamTimeRangeMap = null;
+ this.readType = null;
+ setLimitIsSet(false);
+ this.limit = 0;
+ this.consistency = null;
+ setTargetReplicaIdIsSet(false);
+ this.targetReplicaId = 0;
+ this.filterBytes = null;
+ }
+
+ public byte[] getStartRow() {
+ setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow));
+ return startRow == null ? null : startRow.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStartRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ }
+
+ public TScan setStartRow(byte[] startRow) {
+ this.startRow = startRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(startRow.clone());
+ return this;
+ }
+
+ public TScan setStartRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow) {
+ this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
+ return this;
+ }
+
+ public void unsetStartRow() {
+ this.startRow = null;
+ }
+
+ /** Returns true if field startRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartRow() {
+ return this.startRow != null;
+ }
+
+ public void setStartRowIsSet(boolean value) {
+ if (!value) {
+ this.startRow = null;
+ }
+ }
+
+ public byte[] getStopRow() {
+ setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow));
+ return stopRow == null ? null : stopRow.array();
+ }
+
+ public java.nio.ByteBuffer bufferForStopRow() {
+ return org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ }
+
+ public TScan setStopRow(byte[] stopRow) {
+ this.stopRow = stopRow == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(stopRow.clone());
+ return this;
+ }
+
+ public TScan setStopRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow) {
+ this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(stopRow);
+ return this;
+ }
+
+ public void unsetStopRow() {
+ this.stopRow = null;
+ }
+
+ /** Returns true if field stopRow is set (has been assigned a value) and false otherwise */
+ public boolean isSetStopRow() {
+ return this.stopRow != null;
+ }
+
+ public void setStopRowIsSet(boolean value) {
+ if (!value) {
+ this.stopRow = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumn> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(TColumn elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<TColumn>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumn> getColumns() {
+ return this.columns;
+ }
+
+ public TScan setColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getCaching() {
+ return this.caching;
+ }
+
+ public TScan setCaching(int caching) {
+ this.caching = caching;
+ setCachingIsSet(true);
+ return this;
+ }
+
+ public void unsetCaching() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHING_ISSET_ID);
+ }
+
+ /** Returns true if field caching is set (has been assigned a value) and false otherwise */
+ public boolean isSetCaching() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHING_ISSET_ID);
+ }
+
+ public void setCachingIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHING_ISSET_ID, value);
+ }
+
+ public int getMaxVersions() {
+ return this.maxVersions;
+ }
+
+ public TScan setMaxVersions(int maxVersions) {
+ this.maxVersions = maxVersions;
+ setMaxVersionsIsSet(true);
+ return this;
+ }
+
+ public void unsetMaxVersions() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ /** Returns true if field maxVersions is set (has been assigned a value) and false otherwise */
+ public boolean isSetMaxVersions() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
+ }
+
+ public void setMaxVersionsIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID, value);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TTimeRange getTimeRange() {
+ return this.timeRange;
+ }
+
+ public TScan setTimeRange(@org.apache.thrift.annotation.Nullable TTimeRange timeRange) {
+ this.timeRange = timeRange;
+ return this;
+ }
+
+ public void unsetTimeRange() {
+ this.timeRange = null;
+ }
+
+ /** Returns true if field timeRange is set (has been assigned a value) and false otherwise */
+ public boolean isSetTimeRange() {
+ return this.timeRange != null;
+ }
+
+ public void setTimeRangeIsSet(boolean value) {
+ if (!value) {
+ this.timeRange = null;
+ }
+ }
+
+ public byte[] getFilterString() {
+ setFilterString(org.apache.thrift.TBaseHelper.rightSize(filterString));
+ return filterString == null ? null : filterString.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFilterString() {
+ return org.apache.thrift.TBaseHelper.copyBinary(filterString);
+ }
+
+ public TScan setFilterString(byte[] filterString) {
+ this.filterString = filterString == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(filterString.clone());
+ return this;
+ }
+
+ public TScan setFilterString(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString) {
+ this.filterString = org.apache.thrift.TBaseHelper.copyBinary(filterString);
+ return this;
+ }
+
+ public void unsetFilterString() {
+ this.filterString = null;
+ }
+
+ /** Returns true if field filterString is set (has been assigned a value) and false otherwise */
+ public boolean isSetFilterString() {
+ return this.filterString != null;
+ }
+
+ public void setFilterStringIsSet(boolean value) {
+ if (!value) {
+ this.filterString = null;
+ }
+ }
+
+ public int getBatchSize() {
+ return this.batchSize;
+ }
+
+ public TScan setBatchSize(int batchSize) {
+ this.batchSize = batchSize;
+ setBatchSizeIsSet(true);
+ return this;
+ }
+
+ public void unsetBatchSize() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BATCHSIZE_ISSET_ID);
+ }
+
+ /** Returns true if field batchSize is set (has been assigned a value) and false otherwise */
+ public boolean isSetBatchSize() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BATCHSIZE_ISSET_ID);
+ }
+
+ public void setBatchSizeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BATCHSIZE_ISSET_ID, value);
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TScan setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TAuthorization getAuthorizations() {
+ return this.authorizations;
+ }
+
+ public TScan setAuthorizations(@org.apache.thrift.annotation.Nullable TAuthorization authorizations) {
+ this.authorizations = authorizations;
+ return this;
+ }
+
+ public void unsetAuthorizations() {
+ this.authorizations = null;
+ }
+
+ /** Returns true if field authorizations is set (has been assigned a value) and false otherwise */
+ public boolean isSetAuthorizations() {
+ return this.authorizations != null;
+ }
+
+ public void setAuthorizationsIsSet(boolean value) {
+ if (!value) {
+ this.authorizations = null;
+ }
+ }
+
+ public boolean isReversed() {
+ return this.reversed;
+ }
+
+ public TScan setReversed(boolean reversed) {
+ this.reversed = reversed;
+ setReversedIsSet(true);
+ return this;
+ }
+
+ public void unsetReversed() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __REVERSED_ISSET_ID);
+ }
+
+ /** Returns true if field reversed is set (has been assigned a value) and false otherwise */
+ public boolean isSetReversed() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __REVERSED_ISSET_ID);
+ }
+
+ public void setReversedIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __REVERSED_ISSET_ID, value);
+ }
+
+ public boolean isCacheBlocks() {
+ return this.cacheBlocks;
+ }
+
+ public TScan setCacheBlocks(boolean cacheBlocks) {
+ this.cacheBlocks = cacheBlocks;
+ setCacheBlocksIsSet(true);
+ return this;
+ }
+
+ public void unsetCacheBlocks() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
+ }
+
+ /** Returns true if field cacheBlocks is set (has been assigned a value) and false otherwise */
+ public boolean isSetCacheBlocks() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
+ }
+
+ public void setCacheBlocksIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID, value);
+ }
+
+ public int getColFamTimeRangeMapSize() {
+ return (this.colFamTimeRangeMap == null) ? 0 : this.colFamTimeRangeMap.size();
+ }
+
+ public void putToColFamTimeRangeMap(java.nio.ByteBuffer key, TTimeRange val) {
+ if (this.colFamTimeRangeMap == null) {
+ this.colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>();
+ }
+ this.colFamTimeRangeMap.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,TTimeRange> getColFamTimeRangeMap() {
+ return this.colFamTimeRangeMap;
+ }
+
+ public TScan setColFamTimeRangeMap(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,TTimeRange> colFamTimeRangeMap) {
+ this.colFamTimeRangeMap = colFamTimeRangeMap;
+ return this;
+ }
+
+ public void unsetColFamTimeRangeMap() {
+ this.colFamTimeRangeMap = null;
+ }
+
+ /** Returns true if field colFamTimeRangeMap is set (has been assigned a value) and false otherwise */
+ public boolean isSetColFamTimeRangeMap() {
+ return this.colFamTimeRangeMap != null;
+ }
+
+ public void setColFamTimeRangeMapIsSet(boolean value) {
+ if (!value) {
+ this.colFamTimeRangeMap = null;
+ }
+ }
+
+ /**
+ *
+ * @see TReadType
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TReadType getReadType() {
+ return this.readType;
+ }
+
+ /**
+ *
+ * @see TReadType
+ */
+ public TScan setReadType(@org.apache.thrift.annotation.Nullable TReadType readType) {
+ this.readType = readType;
+ return this;
+ }
+
+ public void unsetReadType() {
+ this.readType = null;
+ }
+
+ /** Returns true if field readType is set (has been assigned a value) and false otherwise */
+ public boolean isSetReadType() {
+ return this.readType != null;
+ }
+
+ public void setReadTypeIsSet(boolean value) {
+ if (!value) {
+ this.readType = null;
+ }
+ }
+
+ public int getLimit() {
+ return this.limit;
+ }
+
+ public TScan setLimit(int limit) {
+ this.limit = limit;
+ setLimitIsSet(true);
+ return this;
+ }
+
+ public void unsetLimit() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LIMIT_ISSET_ID);
+ }
+
+ /** Returns true if field limit is set (has been assigned a value) and false otherwise */
+ public boolean isSetLimit() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LIMIT_ISSET_ID);
+ }
+
+ public void setLimitIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LIMIT_ISSET_ID, value);
+ }
+
+ /**
+ *
+ * @see TConsistency
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TConsistency getConsistency() {
+ return this.consistency;
+ }
+
+ /**
+ *
+ * @see TConsistency
+ */
+ public TScan setConsistency(@org.apache.thrift.annotation.Nullable TConsistency consistency) {
+ this.consistency = consistency;
+ return this;
+ }
+
+ public void unsetConsistency() {
+ this.consistency = null;
+ }
+
+ /** Returns true if field consistency is set (has been assigned a value) and false otherwise */
+ public boolean isSetConsistency() {
+ return this.consistency != null;
+ }
+
+ public void setConsistencyIsSet(boolean value) {
+ if (!value) {
+ this.consistency = null;
+ }
+ }
+
+ public int getTargetReplicaId() {
+ return this.targetReplicaId;
+ }
+
+ public TScan setTargetReplicaId(int targetReplicaId) {
+ this.targetReplicaId = targetReplicaId;
+ setTargetReplicaIdIsSet(true);
+ return this;
+ }
+
+ public void unsetTargetReplicaId() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID);
+ }
+
+ /** Returns true if field targetReplicaId is set (has been assigned a value) and false otherwise */
+ public boolean isSetTargetReplicaId() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID);
+ }
+
+ public void setTargetReplicaIdIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID, value);
+ }
+
+ public byte[] getFilterBytes() {
+ setFilterBytes(org.apache.thrift.TBaseHelper.rightSize(filterBytes));
+ return filterBytes == null ? null : filterBytes.array();
+ }
+
+ public java.nio.ByteBuffer bufferForFilterBytes() {
+ return org.apache.thrift.TBaseHelper.copyBinary(filterBytes);
+ }
+
+ public TScan setFilterBytes(byte[] filterBytes) {
+ this.filterBytes = filterBytes == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(filterBytes.clone());
+ return this;
+ }
+
+ public TScan setFilterBytes(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterBytes) {
+ this.filterBytes = org.apache.thrift.TBaseHelper.copyBinary(filterBytes);
+ return this;
+ }
+
+ public void unsetFilterBytes() {
+ this.filterBytes = null;
+ }
+
+ /** Returns true if field filterBytes is set (has been assigned a value) and false otherwise */
+ public boolean isSetFilterBytes() {
+ return this.filterBytes != null;
+ }
+
+ public void setFilterBytesIsSet(boolean value) {
+ if (!value) {
+ this.filterBytes = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case START_ROW:
+ if (value == null) {
+ unsetStartRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStartRow((byte[])value);
+ } else {
+ setStartRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case STOP_ROW:
+ if (value == null) {
+ unsetStopRow();
+ } else {
+ if (value instanceof byte[]) {
+ setStopRow((byte[])value);
+ } else {
+ setStopRow((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<TColumn>)value);
+ }
+ break;
+
+ case CACHING:
+ if (value == null) {
+ unsetCaching();
+ } else {
+ setCaching((java.lang.Integer)value);
+ }
+ break;
+
+ case MAX_VERSIONS:
+ if (value == null) {
+ unsetMaxVersions();
+ } else {
+ setMaxVersions((java.lang.Integer)value);
+ }
+ break;
+
+ case TIME_RANGE:
+ if (value == null) {
+ unsetTimeRange();
+ } else {
+ setTimeRange((TTimeRange)value);
+ }
+ break;
+
+ case FILTER_STRING:
+ if (value == null) {
+ unsetFilterString();
+ } else {
+ if (value instanceof byte[]) {
+ setFilterString((byte[])value);
+ } else {
+ setFilterString((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case BATCH_SIZE:
+ if (value == null) {
+ unsetBatchSize();
+ } else {
+ setBatchSize((java.lang.Integer)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case AUTHORIZATIONS:
+ if (value == null) {
+ unsetAuthorizations();
+ } else {
+ setAuthorizations((TAuthorization)value);
+ }
+ break;
+
+ case REVERSED:
+ if (value == null) {
+ unsetReversed();
+ } else {
+ setReversed((java.lang.Boolean)value);
+ }
+ break;
+
+ case CACHE_BLOCKS:
+ if (value == null) {
+ unsetCacheBlocks();
+ } else {
+ setCacheBlocks((java.lang.Boolean)value);
+ }
+ break;
+
+ case COL_FAM_TIME_RANGE_MAP:
+ if (value == null) {
+ unsetColFamTimeRangeMap();
+ } else {
+ setColFamTimeRangeMap((java.util.Map<java.nio.ByteBuffer,TTimeRange>)value);
+ }
+ break;
+
+ case READ_TYPE:
+ if (value == null) {
+ unsetReadType();
+ } else {
+ setReadType((TReadType)value);
+ }
+ break;
+
+ case LIMIT:
+ if (value == null) {
+ unsetLimit();
+ } else {
+ setLimit((java.lang.Integer)value);
+ }
+ break;
+
+ case CONSISTENCY:
+ if (value == null) {
+ unsetConsistency();
+ } else {
+ setConsistency((TConsistency)value);
+ }
+ break;
+
+ case TARGET_REPLICA_ID:
+ if (value == null) {
+ unsetTargetReplicaId();
+ } else {
+ setTargetReplicaId((java.lang.Integer)value);
+ }
+ break;
+
+ case FILTER_BYTES:
+ if (value == null) {
+ unsetFilterBytes();
+ } else {
+ if (value instanceof byte[]) {
+ setFilterBytes((byte[])value);
+ } else {
+ setFilterBytes((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case START_ROW:
+ return getStartRow();
+
+ case STOP_ROW:
+ return getStopRow();
+
+ case COLUMNS:
+ return getColumns();
+
+ case CACHING:
+ return getCaching();
+
+ case MAX_VERSIONS:
+ return getMaxVersions();
+
+ case TIME_RANGE:
+ return getTimeRange();
+
+ case FILTER_STRING:
+ return getFilterString();
+
+ case BATCH_SIZE:
+ return getBatchSize();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case AUTHORIZATIONS:
+ return getAuthorizations();
+
+ case REVERSED:
+ return isReversed();
+
+ case CACHE_BLOCKS:
+ return isCacheBlocks();
+
+ case COL_FAM_TIME_RANGE_MAP:
+ return getColFamTimeRangeMap();
+
+ case READ_TYPE:
+ return getReadType();
+
+ case LIMIT:
+ return getLimit();
+
+ case CONSISTENCY:
+ return getConsistency();
+
+ case TARGET_REPLICA_ID:
+ return getTargetReplicaId();
+
+ case FILTER_BYTES:
+ return getFilterBytes();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case START_ROW:
+ return isSetStartRow();
+ case STOP_ROW:
+ return isSetStopRow();
+ case COLUMNS:
+ return isSetColumns();
+ case CACHING:
+ return isSetCaching();
+ case MAX_VERSIONS:
+ return isSetMaxVersions();
+ case TIME_RANGE:
+ return isSetTimeRange();
+ case FILTER_STRING:
+ return isSetFilterString();
+ case BATCH_SIZE:
+ return isSetBatchSize();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case AUTHORIZATIONS:
+ return isSetAuthorizations();
+ case REVERSED:
+ return isSetReversed();
+ case CACHE_BLOCKS:
+ return isSetCacheBlocks();
+ case COL_FAM_TIME_RANGE_MAP:
+ return isSetColFamTimeRangeMap();
+ case READ_TYPE:
+ return isSetReadType();
+ case LIMIT:
+ return isSetLimit();
+ case CONSISTENCY:
+ return isSetConsistency();
+ case TARGET_REPLICA_ID:
+ return isSetTargetReplicaId();
+ case FILTER_BYTES:
+ return isSetFilterBytes();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TScan)
+ return this.equals((TScan)that);
+ return false;
+ }
+
+ public boolean equals(TScan that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_startRow = true && this.isSetStartRow();
+ boolean that_present_startRow = true && that.isSetStartRow();
+ if (this_present_startRow || that_present_startRow) {
+ if (!(this_present_startRow && that_present_startRow))
+ return false;
+ if (!this.startRow.equals(that.startRow))
+ return false;
+ }
+
+ boolean this_present_stopRow = true && this.isSetStopRow();
+ boolean that_present_stopRow = true && that.isSetStopRow();
+ if (this_present_stopRow || that_present_stopRow) {
+ if (!(this_present_stopRow && that_present_stopRow))
+ return false;
+ if (!this.stopRow.equals(that.stopRow))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_caching = true && this.isSetCaching();
+ boolean that_present_caching = true && that.isSetCaching();
+ if (this_present_caching || that_present_caching) {
+ if (!(this_present_caching && that_present_caching))
+ return false;
+ if (this.caching != that.caching)
+ return false;
+ }
+
+ boolean this_present_maxVersions = true && this.isSetMaxVersions();
+ boolean that_present_maxVersions = true && that.isSetMaxVersions();
+ if (this_present_maxVersions || that_present_maxVersions) {
+ if (!(this_present_maxVersions && that_present_maxVersions))
+ return false;
+ if (this.maxVersions != that.maxVersions)
+ return false;
+ }
+
+ boolean this_present_timeRange = true && this.isSetTimeRange();
+ boolean that_present_timeRange = true && that.isSetTimeRange();
+ if (this_present_timeRange || that_present_timeRange) {
+ if (!(this_present_timeRange && that_present_timeRange))
+ return false;
+ if (!this.timeRange.equals(that.timeRange))
+ 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;
+ }
+
+ boolean this_present_batchSize = true && this.isSetBatchSize();
+ boolean that_present_batchSize = true && that.isSetBatchSize();
+ if (this_present_batchSize || that_present_batchSize) {
+ if (!(this_present_batchSize && that_present_batchSize))
+ return false;
+ if (this.batchSize != that.batchSize)
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_authorizations = true && this.isSetAuthorizations();
+ boolean that_present_authorizations = true && that.isSetAuthorizations();
+ if (this_present_authorizations || that_present_authorizations) {
+ if (!(this_present_authorizations && that_present_authorizations))
+ return false;
+ if (!this.authorizations.equals(that.authorizations))
+ return false;
+ }
+
+ boolean this_present_reversed = true && this.isSetReversed();
+ boolean that_present_reversed = true && that.isSetReversed();
+ if (this_present_reversed || that_present_reversed) {
+ if (!(this_present_reversed && that_present_reversed))
+ return false;
+ if (this.reversed != that.reversed)
+ return false;
+ }
+
+ boolean this_present_cacheBlocks = true && this.isSetCacheBlocks();
+ boolean that_present_cacheBlocks = true && that.isSetCacheBlocks();
+ if (this_present_cacheBlocks || that_present_cacheBlocks) {
+ if (!(this_present_cacheBlocks && that_present_cacheBlocks))
+ return false;
+ if (this.cacheBlocks != that.cacheBlocks)
+ return false;
+ }
+
+ boolean this_present_colFamTimeRangeMap = true && this.isSetColFamTimeRangeMap();
+ boolean that_present_colFamTimeRangeMap = true && that.isSetColFamTimeRangeMap();
+ if (this_present_colFamTimeRangeMap || that_present_colFamTimeRangeMap) {
+ if (!(this_present_colFamTimeRangeMap && that_present_colFamTimeRangeMap))
+ return false;
+ if (!this.colFamTimeRangeMap.equals(that.colFamTimeRangeMap))
+ return false;
+ }
+
+ boolean this_present_readType = true && this.isSetReadType();
+ boolean that_present_readType = true && that.isSetReadType();
+ if (this_present_readType || that_present_readType) {
+ if (!(this_present_readType && that_present_readType))
+ return false;
+ if (!this.readType.equals(that.readType))
+ return false;
+ }
+
+ boolean this_present_limit = true && this.isSetLimit();
+ boolean that_present_limit = true && that.isSetLimit();
+ if (this_present_limit || that_present_limit) {
+ if (!(this_present_limit && that_present_limit))
+ return false;
+ if (this.limit != that.limit)
+ return false;
+ }
+
+ boolean this_present_consistency = true && this.isSetConsistency();
+ boolean that_present_consistency = true && that.isSetConsistency();
+ if (this_present_consistency || that_present_consistency) {
+ if (!(this_present_consistency && that_present_consistency))
+ return false;
+ if (!this.consistency.equals(that.consistency))
+ return false;
+ }
+
+ boolean this_present_targetReplicaId = true && this.isSetTargetReplicaId();
+ boolean that_present_targetReplicaId = true && that.isSetTargetReplicaId();
+ if (this_present_targetReplicaId || that_present_targetReplicaId) {
+ if (!(this_present_targetReplicaId && that_present_targetReplicaId))
+ return false;
+ if (this.targetReplicaId != that.targetReplicaId)
+ return false;
+ }
+
+ boolean this_present_filterBytes = true && this.isSetFilterBytes();
+ boolean that_present_filterBytes = true && that.isSetFilterBytes();
+ if (this_present_filterBytes || that_present_filterBytes) {
+ if (!(this_present_filterBytes && that_present_filterBytes))
+ return false;
+ if (!this.filterBytes.equals(that.filterBytes))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetStartRow()) ? 131071 : 524287);
+ if (isSetStartRow())
+ hashCode = hashCode * 8191 + startRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetStopRow()) ? 131071 : 524287);
+ if (isSetStopRow())
+ hashCode = hashCode * 8191 + stopRow.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetCaching()) ? 131071 : 524287);
+ if (isSetCaching())
+ hashCode = hashCode * 8191 + caching;
+
+ hashCode = hashCode * 8191 + ((isSetMaxVersions()) ? 131071 : 524287);
+ if (isSetMaxVersions())
+ hashCode = hashCode * 8191 + maxVersions;
+
+ hashCode = hashCode * 8191 + ((isSetTimeRange()) ? 131071 : 524287);
+ if (isSetTimeRange())
+ hashCode = hashCode * 8191 + timeRange.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetFilterString()) ? 131071 : 524287);
+ if (isSetFilterString())
+ hashCode = hashCode * 8191 + filterString.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetBatchSize()) ? 131071 : 524287);
+ if (isSetBatchSize())
+ hashCode = hashCode * 8191 + batchSize;
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAuthorizations()) ? 131071 : 524287);
+ if (isSetAuthorizations())
+ hashCode = hashCode * 8191 + authorizations.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetReversed()) ? 131071 : 524287);
+ if (isSetReversed())
+ hashCode = hashCode * 8191 + ((reversed) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetCacheBlocks()) ? 131071 : 524287);
+ if (isSetCacheBlocks())
+ hashCode = hashCode * 8191 + ((cacheBlocks) ? 131071 : 524287);
+
+ hashCode = hashCode * 8191 + ((isSetColFamTimeRangeMap()) ? 131071 : 524287);
+ if (isSetColFamTimeRangeMap())
+ hashCode = hashCode * 8191 + colFamTimeRangeMap.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetReadType()) ? 131071 : 524287);
+ if (isSetReadType())
+ hashCode = hashCode * 8191 + readType.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetLimit()) ? 131071 : 524287);
+ if (isSetLimit())
+ hashCode = hashCode * 8191 + limit;
+
+ hashCode = hashCode * 8191 + ((isSetConsistency()) ? 131071 : 524287);
+ if (isSetConsistency())
+ hashCode = hashCode * 8191 + consistency.getValue();
+
+ hashCode = hashCode * 8191 + ((isSetTargetReplicaId()) ? 131071 : 524287);
+ if (isSetTargetReplicaId())
+ hashCode = hashCode * 8191 + targetReplicaId;
+
+ hashCode = hashCode * 8191 + ((isSetFilterBytes()) ? 131071 : 524287);
+ if (isSetFilterBytes())
+ hashCode = hashCode * 8191 + filterBytes.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TScan other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetStartRow(), other.isSetStartRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, other.startRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStopRow(), other.isSetStopRow());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStopRow()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, other.stopRow);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCaching(), other.isSetCaching());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCaching()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.caching, other.caching);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMaxVersions(), other.isSetMaxVersions());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMaxVersions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxVersions, other.maxVersions);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTimeRange(), other.isSetTimeRange());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTimeRange()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeRange, other.timeRange);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFilterString(), other.isSetFilterString());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFilterString()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterString, other.filterString);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetBatchSize(), other.isSetBatchSize());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetBatchSize()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.batchSize, other.batchSize);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAuthorizations(), other.isSetAuthorizations());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAuthorizations()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authorizations, other.authorizations);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetReversed(), other.isSetReversed());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReversed()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.reversed, other.reversed);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetCacheBlocks(), other.isSetCacheBlocks());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetCacheBlocks()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheBlocks, other.cacheBlocks);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColFamTimeRangeMap(), other.isSetColFamTimeRangeMap());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColFamTimeRangeMap()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colFamTimeRangeMap, other.colFamTimeRangeMap);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetReadType(), other.isSetReadType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReadType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.readType, other.readType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetLimit(), other.isSetLimit());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetLimit()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limit, other.limit);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetConsistency(), other.isSetConsistency());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetConsistency()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.consistency, other.consistency);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetTargetReplicaId(), other.isSetTargetReplicaId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTargetReplicaId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.targetReplicaId, other.targetReplicaId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetFilterBytes(), other.isSetFilterBytes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetFilterBytes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterBytes, other.filterBytes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TScan(");
+ boolean first = true;
+
+ if (isSetStartRow()) {
+ sb.append("startRow:");
+ if (this.startRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
+ }
+ first = false;
+ }
+ if (isSetStopRow()) {
+ if (!first) sb.append(", ");
+ sb.append("stopRow:");
+ if (this.stopRow == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.stopRow, sb);
+ }
+ first = false;
+ }
+ if (isSetColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columns);
+ }
+ first = false;
+ }
+ if (isSetCaching()) {
+ if (!first) sb.append(", ");
+ sb.append("caching:");
+ sb.append(this.caching);
+ first = false;
+ }
+ if (isSetMaxVersions()) {
+ if (!first) sb.append(", ");
+ sb.append("maxVersions:");
+ sb.append(this.maxVersions);
+ first = false;
+ }
+ if (isSetTimeRange()) {
+ if (!first) sb.append(", ");
+ sb.append("timeRange:");
+ if (this.timeRange == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.timeRange);
+ }
+ first = false;
+ }
+ if (isSetFilterString()) {
+ if (!first) sb.append(", ");
+ sb.append("filterString:");
+ if (this.filterString == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.filterString, sb);
+ }
+ first = false;
+ }
+ if (isSetBatchSize()) {
+ if (!first) sb.append(", ");
+ sb.append("batchSize:");
+ sb.append(this.batchSize);
+ first = false;
+ }
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetAuthorizations()) {
+ if (!first) sb.append(", ");
+ sb.append("authorizations:");
+ if (this.authorizations == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.authorizations);
+ }
+ first = false;
+ }
+ if (isSetReversed()) {
+ if (!first) sb.append(", ");
+ sb.append("reversed:");
+ sb.append(this.reversed);
+ first = false;
+ }
+ if (isSetCacheBlocks()) {
+ if (!first) sb.append(", ");
+ sb.append("cacheBlocks:");
+ sb.append(this.cacheBlocks);
+ first = false;
+ }
+ if (isSetColFamTimeRangeMap()) {
+ if (!first) sb.append(", ");
+ sb.append("colFamTimeRangeMap:");
+ if (this.colFamTimeRangeMap == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.colFamTimeRangeMap);
+ }
+ first = false;
+ }
+ if (isSetReadType()) {
+ if (!first) sb.append(", ");
+ sb.append("readType:");
+ if (this.readType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.readType);
+ }
+ first = false;
+ }
+ if (isSetLimit()) {
+ if (!first) sb.append(", ");
+ sb.append("limit:");
+ sb.append(this.limit);
+ first = false;
+ }
+ if (isSetConsistency()) {
+ if (!first) sb.append(", ");
+ sb.append("consistency:");
+ if (this.consistency == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.consistency);
+ }
+ first = false;
+ }
+ if (isSetTargetReplicaId()) {
+ if (!first) sb.append(", ");
+ sb.append("targetReplicaId:");
+ sb.append(this.targetReplicaId);
+ first = false;
+ }
+ if (isSetFilterBytes()) {
+ if (!first) sb.append(", ");
+ sb.append("filterBytes:");
+ if (this.filterBytes == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.filterBytes, sb);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (timeRange != null) {
+ timeRange.validate();
+ }
+ if (authorizations != null) {
+ authorizations.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TScanStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TScanStandardScheme getScheme() {
+ return new TScanStandardScheme();
+ }
+ }
+
+ private static class TScanStandardScheme extends org.apache.thrift.scheme.StandardScheme<TScan> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TScan struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // START_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // STOP_ROW
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list106 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<TColumn>(_list106.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem107;
+ for (int _i108 = 0; _i108 < _list106.size; ++_i108)
+ {
+ _elem107 = new TColumn();
+ _elem107.read(iprot);
+ struct.columns.add(_elem107);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // CACHING
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.caching = iprot.readI32();
+ struct.setCachingIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // MAX_VERSIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // TIME_RANGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.timeRange = new TTimeRange();
+ struct.timeRange.read(iprot);
+ struct.setTimeRangeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // FILTER_STRING
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.filterString = iprot.readBinary();
+ struct.setFilterStringIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 8: // BATCH_SIZE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.batchSize = iprot.readI32();
+ struct.setBatchSizeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 9: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map109 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map109.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key110;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val111;
+ for (int _i112 = 0; _i112 < _map109.size; ++_i112)
+ {
+ _key110 = iprot.readBinary();
+ _val111 = iprot.readBinary();
+ struct.attributes.put(_key110, _val111);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 10: // AUTHORIZATIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.authorizations = new TAuthorization();
+ struct.authorizations.read(iprot);
+ struct.setAuthorizationsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 11: // REVERSED
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.reversed = iprot.readBool();
+ struct.setReversedIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 12: // CACHE_BLOCKS
+ if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+ struct.cacheBlocks = iprot.readBool();
+ struct.setCacheBlocksIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 13: // COL_FAM_TIME_RANGE_MAP
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map113 = iprot.readMapBegin();
+ struct.colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>(2*_map113.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key114;
+ @org.apache.thrift.annotation.Nullable TTimeRange _val115;
+ for (int _i116 = 0; _i116 < _map113.size; ++_i116)
+ {
+ _key114 = iprot.readBinary();
+ _val115 = new TTimeRange();
+ _val115.read(iprot);
+ struct.colFamTimeRangeMap.put(_key114, _val115);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setColFamTimeRangeMapIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 14: // READ_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.readType = org.apache.hadoop.hbase.thrift2.generated.TReadType.findByValue(iprot.readI32());
+ struct.setReadTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 15: // LIMIT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.limit = iprot.readI32();
+ struct.setLimitIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 16: // CONSISTENCY
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.consistency = org.apache.hadoop.hbase.thrift2.generated.TConsistency.findByValue(iprot.readI32());
+ struct.setConsistencyIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 17: // TARGET_REPLICA_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.targetReplicaId = iprot.readI32();
+ struct.setTargetReplicaIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 18: // FILTER_BYTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.filterBytes = iprot.readBinary();
+ struct.setFilterBytesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TScan struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.startRow != null) {
+ if (struct.isSetStartRow()) {
+ oprot.writeFieldBegin(START_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.startRow);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.stopRow != null) {
+ if (struct.isSetStopRow()) {
+ oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
+ oprot.writeBinary(struct.stopRow);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.columns != null) {
+ if (struct.isSetColumns()) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+ for (TColumn _iter117 : struct.columns)
+ {
+ _iter117.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetCaching()) {
+ oprot.writeFieldBegin(CACHING_FIELD_DESC);
+ oprot.writeI32(struct.caching);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetMaxVersions()) {
+ oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
+ oprot.writeI32(struct.maxVersions);
+ oprot.writeFieldEnd();
+ }
+ if (struct.timeRange != null) {
+ if (struct.isSetTimeRange()) {
+ oprot.writeFieldBegin(TIME_RANGE_FIELD_DESC);
+ struct.timeRange.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.filterString != null) {
+ if (struct.isSetFilterString()) {
+ oprot.writeFieldBegin(FILTER_STRING_FIELD_DESC);
+ oprot.writeBinary(struct.filterString);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetBatchSize()) {
+ oprot.writeFieldBegin(BATCH_SIZE_FIELD_DESC);
+ oprot.writeI32(struct.batchSize);
+ oprot.writeFieldEnd();
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter118 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter118.getKey());
+ oprot.writeBinary(_iter118.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.authorizations != null) {
+ if (struct.isSetAuthorizations()) {
+ oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC);
+ struct.authorizations.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetReversed()) {
+ oprot.writeFieldBegin(REVERSED_FIELD_DESC);
+ oprot.writeBool(struct.reversed);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetCacheBlocks()) {
+ oprot.writeFieldBegin(CACHE_BLOCKS_FIELD_DESC);
+ oprot.writeBool(struct.cacheBlocks);
+ oprot.writeFieldEnd();
+ }
+ if (struct.colFamTimeRangeMap != null) {
+ if (struct.isSetColFamTimeRangeMap()) {
+ oprot.writeFieldBegin(COL_FAM_TIME_RANGE_MAP_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.colFamTimeRangeMap.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, TTimeRange> _iter119 : struct.colFamTimeRangeMap.entrySet())
+ {
+ oprot.writeBinary(_iter119.getKey());
+ _iter119.getValue().write(oprot);
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.readType != null) {
+ if (struct.isSetReadType()) {
+ oprot.writeFieldBegin(READ_TYPE_FIELD_DESC);
+ oprot.writeI32(struct.readType.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetLimit()) {
+ oprot.writeFieldBegin(LIMIT_FIELD_DESC);
+ oprot.writeI32(struct.limit);
+ oprot.writeFieldEnd();
+ }
+ if (struct.consistency != null) {
+ if (struct.isSetConsistency()) {
+ oprot.writeFieldBegin(CONSISTENCY_FIELD_DESC);
+ oprot.writeI32(struct.consistency.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.isSetTargetReplicaId()) {
+ oprot.writeFieldBegin(TARGET_REPLICA_ID_FIELD_DESC);
+ oprot.writeI32(struct.targetReplicaId);
+ oprot.writeFieldEnd();
+ }
+ if (struct.filterBytes != null) {
+ if (struct.isSetFilterBytes()) {
+ oprot.writeFieldBegin(FILTER_BYTES_FIELD_DESC);
+ oprot.writeBinary(struct.filterBytes);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TScanTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TScanTupleScheme getScheme() {
+ return new TScanTupleScheme();
+ }
+ }
+
+ private static class TScanTupleScheme extends org.apache.thrift.scheme.TupleScheme<TScan> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TScan struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetStartRow()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStopRow()) {
+ optionals.set(1);
+ }
+ if (struct.isSetColumns()) {
+ optionals.set(2);
+ }
+ if (struct.isSetCaching()) {
+ optionals.set(3);
+ }
+ if (struct.isSetMaxVersions()) {
+ optionals.set(4);
+ }
+ if (struct.isSetTimeRange()) {
+ optionals.set(5);
+ }
+ if (struct.isSetFilterString()) {
+ optionals.set(6);
+ }
+ if (struct.isSetBatchSize()) {
+ optionals.set(7);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(8);
+ }
+ if (struct.isSetAuthorizations()) {
+ optionals.set(9);
+ }
+ if (struct.isSetReversed()) {
+ optionals.set(10);
+ }
+ if (struct.isSetCacheBlocks()) {
+ optionals.set(11);
+ }
+ if (struct.isSetColFamTimeRangeMap()) {
+ optionals.set(12);
+ }
+ if (struct.isSetReadType()) {
+ optionals.set(13);
+ }
+ if (struct.isSetLimit()) {
+ optionals.set(14);
+ }
+ if (struct.isSetConsistency()) {
+ optionals.set(15);
+ }
+ if (struct.isSetTargetReplicaId()) {
+ optionals.set(16);
+ }
+ if (struct.isSetFilterBytes()) {
+ optionals.set(17);
+ }
+ oprot.writeBitSet(optionals, 18);
+ if (struct.isSetStartRow()) {
+ oprot.writeBinary(struct.startRow);
+ }
+ if (struct.isSetStopRow()) {
+ oprot.writeBinary(struct.stopRow);
+ }
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (TColumn _iter120 : struct.columns)
+ {
+ _iter120.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetCaching()) {
+ oprot.writeI32(struct.caching);
+ }
+ if (struct.isSetMaxVersions()) {
+ oprot.writeI32(struct.maxVersions);
+ }
+ if (struct.isSetTimeRange()) {
+ struct.timeRange.write(oprot);
+ }
+ if (struct.isSetFilterString()) {
+ oprot.writeBinary(struct.filterString);
+ }
+ if (struct.isSetBatchSize()) {
+ oprot.writeI32(struct.batchSize);
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter121 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter121.getKey());
+ oprot.writeBinary(_iter121.getValue());
+ }
+ }
+ }
+ if (struct.isSetAuthorizations()) {
+ struct.authorizations.write(oprot);
+ }
+ if (struct.isSetReversed()) {
+ oprot.writeBool(struct.reversed);
+ }
+ if (struct.isSetCacheBlocks()) {
+ oprot.writeBool(struct.cacheBlocks);
+ }
+ if (struct.isSetColFamTimeRangeMap()) {
+ {
+ oprot.writeI32(struct.colFamTimeRangeMap.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, TTimeRange> _iter122 : struct.colFamTimeRangeMap.entrySet())
+ {
+ oprot.writeBinary(_iter122.getKey());
+ _iter122.getValue().write(oprot);
+ }
+ }
+ }
+ if (struct.isSetReadType()) {
+ oprot.writeI32(struct.readType.getValue());
+ }
+ if (struct.isSetLimit()) {
+ oprot.writeI32(struct.limit);
+ }
+ if (struct.isSetConsistency()) {
+ oprot.writeI32(struct.consistency.getValue());
+ }
+ if (struct.isSetTargetReplicaId()) {
+ oprot.writeI32(struct.targetReplicaId);
+ }
+ if (struct.isSetFilterBytes()) {
+ oprot.writeBinary(struct.filterBytes);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TScan struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(18);
+ if (incoming.get(0)) {
+ struct.startRow = iprot.readBinary();
+ struct.setStartRowIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.stopRow = iprot.readBinary();
+ struct.setStopRowIsSet(true);
+ }
+ if (incoming.get(2)) {
+ {
+ org.apache.thrift.protocol.TList _list123 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columns = new java.util.ArrayList<TColumn>(_list123.size);
+ @org.apache.thrift.annotation.Nullable TColumn _elem124;
+ for (int _i125 = 0; _i125 < _list123.size; ++_i125)
+ {
+ _elem124 = new TColumn();
+ _elem124.read(iprot);
+ struct.columns.add(_elem124);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.caching = iprot.readI32();
+ struct.setCachingIsSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.maxVersions = iprot.readI32();
+ struct.setMaxVersionsIsSet(true);
+ }
+ if (incoming.get(5)) {
+ struct.timeRange = new TTimeRange();
+ struct.timeRange.read(iprot);
+ struct.setTimeRangeIsSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.filterString = iprot.readBinary();
+ struct.setFilterStringIsSet(true);
+ }
+ if (incoming.get(7)) {
+ struct.batchSize = iprot.readI32();
+ struct.setBatchSizeIsSet(true);
+ }
+ if (incoming.get(8)) {
+ {
+ org.apache.thrift.protocol.TMap _map126 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map126.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key127;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val128;
+ for (int _i129 = 0; _i129 < _map126.size; ++_i129)
+ {
+ _key127 = iprot.readBinary();
+ _val128 = iprot.readBinary();
+ struct.attributes.put(_key127, _val128);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(9)) {
+ struct.authorizations = new TAuthorization();
+ struct.authorizations.read(iprot);
+ struct.setAuthorizationsIsSet(true);
+ }
+ if (incoming.get(10)) {
+ struct.reversed = iprot.readBool();
+ struct.setReversedIsSet(true);
+ }
+ if (incoming.get(11)) {
+ struct.cacheBlocks = iprot.readBool();
+ struct.setCacheBlocksIsSet(true);
+ }
+ if (incoming.get(12)) {
+ {
+ org.apache.thrift.protocol.TMap _map130 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT);
+ struct.colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>(2*_map130.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key131;
+ @org.apache.thrift.annotation.Nullable TTimeRange _val132;
+ for (int _i133 = 0; _i133 < _map130.size; ++_i133)
+ {
+ _key131 = iprot.readBinary();
+ _val132 = new TTimeRange();
+ _val132.read(iprot);
+ struct.colFamTimeRangeMap.put(_key131, _val132);
+ }
+ }
+ struct.setColFamTimeRangeMapIsSet(true);
+ }
+ if (incoming.get(13)) {
+ struct.readType = org.apache.hadoop.hbase.thrift2.generated.TReadType.findByValue(iprot.readI32());
+ struct.setReadTypeIsSet(true);
+ }
+ if (incoming.get(14)) {
+ struct.limit = iprot.readI32();
+ struct.setLimitIsSet(true);
+ }
+ if (incoming.get(15)) {
+ struct.consistency = org.apache.hadoop.hbase.thrift2.generated.TConsistency.findByValue(iprot.readI32());
+ struct.setConsistencyIsSet(true);
+ }
+ if (incoming.get(16)) {
+ struct.targetReplicaId = iprot.readI32();
+ struct.setTargetReplicaIdIsSet(true);
+ }
+ if (incoming.get(17)) {
+ struct.filterBytes = iprot.readBinary();
+ struct.setFilterBytesIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TServerName.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TServerName.java
new file mode 100644
index 0000000..ec426e3
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TServerName.java
@@ -0,0 +1,574 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TServerName implements org.apache.thrift.TBase<TServerName, TServerName._Fields>, java.io.Serializable, Cloneable, Comparable<TServerName> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TServerName");
+
+ private static final org.apache.thrift.protocol.TField HOST_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("hostName", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField PORT_FIELD_DESC = new org.apache.thrift.protocol.TField("port", org.apache.thrift.protocol.TType.I32, (short)2);
+ private static final org.apache.thrift.protocol.TField START_CODE_FIELD_DESC = new org.apache.thrift.protocol.TField("startCode", org.apache.thrift.protocol.TType.I64, (short)3);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TServerNameStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TServerNameTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable java.lang.String hostName; // required
+ public int port; // optional
+ public long startCode; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ HOST_NAME((short)1, "hostName"),
+ PORT((short)2, "port"),
+ START_CODE((short)3, "startCode");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // HOST_NAME
+ return HOST_NAME;
+ case 2: // PORT
+ return PORT;
+ case 3: // START_CODE
+ return START_CODE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __PORT_ISSET_ID = 0;
+ private static final int __STARTCODE_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.PORT,_Fields.START_CODE};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.HOST_NAME, new org.apache.thrift.meta_data.FieldMetaData("hostName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.PORT, new org.apache.thrift.meta_data.FieldMetaData("port", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.START_CODE, new org.apache.thrift.meta_data.FieldMetaData("startCode", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TServerName.class, metaDataMap);
+ }
+
+ public TServerName() {
+ }
+
+ public TServerName(
+ java.lang.String hostName)
+ {
+ this();
+ this.hostName = hostName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TServerName(TServerName other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.isSetHostName()) {
+ this.hostName = other.hostName;
+ }
+ this.port = other.port;
+ this.startCode = other.startCode;
+ }
+
+ public TServerName deepCopy() {
+ return new TServerName(this);
+ }
+
+ @Override
+ public void clear() {
+ this.hostName = null;
+ setPortIsSet(false);
+ this.port = 0;
+ setStartCodeIsSet(false);
+ this.startCode = 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getHostName() {
+ return this.hostName;
+ }
+
+ public TServerName setHostName(@org.apache.thrift.annotation.Nullable java.lang.String hostName) {
+ this.hostName = hostName;
+ return this;
+ }
+
+ public void unsetHostName() {
+ this.hostName = null;
+ }
+
+ /** Returns true if field hostName is set (has been assigned a value) and false otherwise */
+ public boolean isSetHostName() {
+ return this.hostName != null;
+ }
+
+ public void setHostNameIsSet(boolean value) {
+ if (!value) {
+ this.hostName = null;
+ }
+ }
+
+ public int getPort() {
+ return this.port;
+ }
+
+ public TServerName setPort(int port) {
+ this.port = port;
+ setPortIsSet(true);
+ return this;
+ }
+
+ public void unsetPort() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PORT_ISSET_ID);
+ }
+
+ /** Returns true if field port is set (has been assigned a value) and false otherwise */
+ public boolean isSetPort() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PORT_ISSET_ID);
+ }
+
+ public void setPortIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PORT_ISSET_ID, value);
+ }
+
+ public long getStartCode() {
+ return this.startCode;
+ }
+
+ public TServerName setStartCode(long startCode) {
+ this.startCode = startCode;
+ setStartCodeIsSet(true);
+ return this;
+ }
+
+ public void unsetStartCode() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __STARTCODE_ISSET_ID);
+ }
+
+ /** Returns true if field startCode is set (has been assigned a value) and false otherwise */
+ public boolean isSetStartCode() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __STARTCODE_ISSET_ID);
+ }
+
+ public void setStartCodeIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __STARTCODE_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case HOST_NAME:
+ if (value == null) {
+ unsetHostName();
+ } else {
+ setHostName((java.lang.String)value);
+ }
+ break;
+
+ case PORT:
+ if (value == null) {
+ unsetPort();
+ } else {
+ setPort((java.lang.Integer)value);
+ }
+ break;
+
+ case START_CODE:
+ if (value == null) {
+ unsetStartCode();
+ } else {
+ setStartCode((java.lang.Long)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case HOST_NAME:
+ return getHostName();
+
+ case PORT:
+ return getPort();
+
+ case START_CODE:
+ return getStartCode();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case HOST_NAME:
+ return isSetHostName();
+ case PORT:
+ return isSetPort();
+ case START_CODE:
+ return isSetStartCode();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TServerName)
+ return this.equals((TServerName)that);
+ return false;
+ }
+
+ public boolean equals(TServerName that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_hostName = true && this.isSetHostName();
+ boolean that_present_hostName = true && that.isSetHostName();
+ if (this_present_hostName || that_present_hostName) {
+ if (!(this_present_hostName && that_present_hostName))
+ return false;
+ if (!this.hostName.equals(that.hostName))
+ return false;
+ }
+
+ boolean this_present_port = true && this.isSetPort();
+ boolean that_present_port = true && that.isSetPort();
+ if (this_present_port || that_present_port) {
+ if (!(this_present_port && that_present_port))
+ return false;
+ if (this.port != that.port)
+ return false;
+ }
+
+ boolean this_present_startCode = true && this.isSetStartCode();
+ boolean that_present_startCode = true && that.isSetStartCode();
+ if (this_present_startCode || that_present_startCode) {
+ if (!(this_present_startCode && that_present_startCode))
+ return false;
+ if (this.startCode != that.startCode)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetHostName()) ? 131071 : 524287);
+ if (isSetHostName())
+ hashCode = hashCode * 8191 + hostName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetPort()) ? 131071 : 524287);
+ if (isSetPort())
+ hashCode = hashCode * 8191 + port;
+
+ hashCode = hashCode * 8191 + ((isSetStartCode()) ? 131071 : 524287);
+ if (isSetStartCode())
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(startCode);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TServerName other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetHostName(), other.isSetHostName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetHostName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.hostName, other.hostName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetPort(), other.isSetPort());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetPort()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.port, other.port);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetStartCode(), other.isSetStartCode());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStartCode()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startCode, other.startCode);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TServerName(");
+ boolean first = true;
+
+ sb.append("hostName:");
+ if (this.hostName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.hostName);
+ }
+ first = false;
+ if (isSetPort()) {
+ if (!first) sb.append(", ");
+ sb.append("port:");
+ sb.append(this.port);
+ first = false;
+ }
+ if (isSetStartCode()) {
+ if (!first) sb.append(", ");
+ sb.append("startCode:");
+ sb.append(this.startCode);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (hostName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'hostName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TServerNameStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TServerNameStandardScheme getScheme() {
+ return new TServerNameStandardScheme();
+ }
+ }
+
+ private static class TServerNameStandardScheme extends org.apache.thrift.scheme.StandardScheme<TServerName> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TServerName struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // HOST_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.hostName = iprot.readString();
+ struct.setHostNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // PORT
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.port = iprot.readI32();
+ struct.setPortIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // START_CODE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.startCode = iprot.readI64();
+ struct.setStartCodeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TServerName struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.hostName != null) {
+ oprot.writeFieldBegin(HOST_NAME_FIELD_DESC);
+ oprot.writeString(struct.hostName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetPort()) {
+ oprot.writeFieldBegin(PORT_FIELD_DESC);
+ oprot.writeI32(struct.port);
+ oprot.writeFieldEnd();
+ }
+ if (struct.isSetStartCode()) {
+ oprot.writeFieldBegin(START_CODE_FIELD_DESC);
+ oprot.writeI64(struct.startCode);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TServerNameTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TServerNameTupleScheme getScheme() {
+ return new TServerNameTupleScheme();
+ }
+ }
+
+ private static class TServerNameTupleScheme extends org.apache.thrift.scheme.TupleScheme<TServerName> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TServerName struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeString(struct.hostName);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetPort()) {
+ optionals.set(0);
+ }
+ if (struct.isSetStartCode()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetPort()) {
+ oprot.writeI32(struct.port);
+ }
+ if (struct.isSetStartCode()) {
+ oprot.writeI64(struct.startCode);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TServerName struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.hostName = iprot.readString();
+ struct.setHostNameIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.port = iprot.readI32();
+ struct.setPortIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.startCode = iprot.readI64();
+ struct.setStartCodeIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableDescriptor.java
new file mode 100644
index 0000000..7a3079a
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableDescriptor.java
@@ -0,0 +1,825 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.TableDescriptor
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TTableDescriptor implements org.apache.thrift.TBase<TTableDescriptor, TTableDescriptor._Fields>, java.io.Serializable, Cloneable, Comparable<TTableDescriptor> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTableDescriptor");
+
+ private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ 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)2);
+ private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)3);
+ private static final org.apache.thrift.protocol.TField DURABILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("durability", org.apache.thrift.protocol.TType.I32, (short)4);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TTableDescriptorStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TTableDescriptorTupleSchemeFactory();
+
+ public @org.apache.thrift.annotation.Nullable TTableName tableName; // required
+ public @org.apache.thrift.annotation.Nullable java.util.List<TColumnFamilyDescriptor> columns; // optional
+ public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
+ /**
+ *
+ * @see TDurability
+ */
+ public @org.apache.thrift.annotation.Nullable TDurability durability; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ TABLE_NAME((short)1, "tableName"),
+ COLUMNS((short)2, "columns"),
+ ATTRIBUTES((short)3, "attributes"),
+ /**
+ *
+ * @see TDurability
+ */
+ DURABILITY((short)4, "durability");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // TABLE_NAME
+ return TABLE_NAME;
+ case 2: // COLUMNS
+ return COLUMNS;
+ case 3: // ATTRIBUTES
+ return ATTRIBUTES;
+ case 4: // DURABILITY
+ return DURABILITY;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.COLUMNS,_Fields.ATTRIBUTES,_Fields.DURABILITY};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTableName.class)));
+ 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumnFamilyDescriptor.class))));
+ tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ 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 , true),
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))));
+ tmpMap.put(_Fields.DURABILITY, new org.apache.thrift.meta_data.FieldMetaData("durability", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDurability.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TTableDescriptor.class, metaDataMap);
+ }
+
+ public TTableDescriptor() {
+ }
+
+ public TTableDescriptor(
+ TTableName tableName)
+ {
+ this();
+ this.tableName = tableName;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TTableDescriptor(TTableDescriptor other) {
+ if (other.isSetTableName()) {
+ this.tableName = new TTableName(other.tableName);
+ }
+ if (other.isSetColumns()) {
+ java.util.List<TColumnFamilyDescriptor> __this__columns = new java.util.ArrayList<TColumnFamilyDescriptor>(other.columns.size());
+ for (TColumnFamilyDescriptor other_element : other.columns) {
+ __this__columns.add(new TColumnFamilyDescriptor(other_element));
+ }
+ this.columns = __this__columns;
+ }
+ if (other.isSetAttributes()) {
+ java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
+ this.attributes = __this__attributes;
+ }
+ if (other.isSetDurability()) {
+ this.durability = other.durability;
+ }
+ }
+
+ public TTableDescriptor deepCopy() {
+ return new TTableDescriptor(this);
+ }
+
+ @Override
+ public void clear() {
+ this.tableName = null;
+ this.columns = null;
+ this.attributes = null;
+ this.durability = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TTableName getTableName() {
+ return this.tableName;
+ }
+
+ public TTableDescriptor setTableName(@org.apache.thrift.annotation.Nullable TTableName tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getColumnsSize() {
+ return (this.columns == null) ? 0 : this.columns.size();
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Iterator<TColumnFamilyDescriptor> getColumnsIterator() {
+ return (this.columns == null) ? null : this.columns.iterator();
+ }
+
+ public void addToColumns(TColumnFamilyDescriptor elem) {
+ if (this.columns == null) {
+ this.columns = new java.util.ArrayList<TColumnFamilyDescriptor>();
+ }
+ this.columns.add(elem);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.List<TColumnFamilyDescriptor> getColumns() {
+ return this.columns;
+ }
+
+ public TTableDescriptor setColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumnFamilyDescriptor> columns) {
+ this.columns = columns;
+ return this;
+ }
+
+ public void unsetColumns() {
+ this.columns = null;
+ }
+
+ /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+ public boolean isSetColumns() {
+ return this.columns != null;
+ }
+
+ public void setColumnsIsSet(boolean value) {
+ if (!value) {
+ this.columns = null;
+ }
+ }
+
+ public int getAttributesSize() {
+ return (this.attributes == null) ? 0 : this.attributes.size();
+ }
+
+ public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
+ if (this.attributes == null) {
+ this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
+ }
+ this.attributes.put(key, val);
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
+ return this.attributes;
+ }
+
+ public TTableDescriptor setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes) {
+ this.attributes = attributes;
+ return this;
+ }
+
+ public void unsetAttributes() {
+ this.attributes = null;
+ }
+
+ /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+ public boolean isSetAttributes() {
+ return this.attributes != null;
+ }
+
+ public void setAttributesIsSet(boolean value) {
+ if (!value) {
+ this.attributes = null;
+ }
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ @org.apache.thrift.annotation.Nullable
+ public TDurability getDurability() {
+ return this.durability;
+ }
+
+ /**
+ *
+ * @see TDurability
+ */
+ public TTableDescriptor setDurability(@org.apache.thrift.annotation.Nullable TDurability durability) {
+ this.durability = durability;
+ return this;
+ }
+
+ public void unsetDurability() {
+ this.durability = null;
+ }
+
+ /** Returns true if field durability is set (has been assigned a value) and false otherwise */
+ public boolean isSetDurability() {
+ return this.durability != null;
+ }
+
+ public void setDurabilityIsSet(boolean value) {
+ if (!value) {
+ this.durability = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((TTableName)value);
+ }
+ break;
+
+ case COLUMNS:
+ if (value == null) {
+ unsetColumns();
+ } else {
+ setColumns((java.util.List<TColumnFamilyDescriptor>)value);
+ }
+ break;
+
+ case ATTRIBUTES:
+ if (value == null) {
+ unsetAttributes();
+ } else {
+ setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
+ }
+ break;
+
+ case DURABILITY:
+ if (value == null) {
+ unsetDurability();
+ } else {
+ setDurability((TDurability)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case COLUMNS:
+ return getColumns();
+
+ case ATTRIBUTES:
+ return getAttributes();
+
+ case DURABILITY:
+ return getDurability();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case COLUMNS:
+ return isSetColumns();
+ case ATTRIBUTES:
+ return isSetAttributes();
+ case DURABILITY:
+ return isSetDurability();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TTableDescriptor)
+ return this.equals((TTableDescriptor)that);
+ return false;
+ }
+
+ public boolean equals(TTableDescriptor that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_columns = true && this.isSetColumns();
+ boolean that_present_columns = true && that.isSetColumns();
+ if (this_present_columns || that_present_columns) {
+ if (!(this_present_columns && that_present_columns))
+ return false;
+ if (!this.columns.equals(that.columns))
+ return false;
+ }
+
+ boolean this_present_attributes = true && this.isSetAttributes();
+ boolean that_present_attributes = true && that.isSetAttributes();
+ if (this_present_attributes || that_present_attributes) {
+ if (!(this_present_attributes && that_present_attributes))
+ return false;
+ if (!this.attributes.equals(that.attributes))
+ return false;
+ }
+
+ boolean this_present_durability = true && this.isSetDurability();
+ boolean that_present_durability = true && that.isSetDurability();
+ if (this_present_durability || that_present_durability) {
+ if (!(this_present_durability && that_present_durability))
+ return false;
+ if (!this.durability.equals(that.durability))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
+ if (isSetTableName())
+ hashCode = hashCode * 8191 + tableName.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
+ if (isSetColumns())
+ hashCode = hashCode * 8191 + columns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
+ if (isSetAttributes())
+ hashCode = hashCode * 8191 + attributes.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetDurability()) ? 131071 : 524287);
+ if (isSetDurability())
+ hashCode = hashCode * 8191 + durability.getValue();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TTableDescriptor other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetColumns(), other.isSetColumns());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumns()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetAttributes(), other.isSetAttributes());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAttributes()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetDurability(), other.isSetDurability());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDurability()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.durability, other.durability);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TTableDescriptor(");
+ boolean first = true;
+
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ if (isSetColumns()) {
+ if (!first) sb.append(", ");
+ sb.append("columns:");
+ if (this.columns == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.columns);
+ }
+ first = false;
+ }
+ if (isSetAttributes()) {
+ if (!first) sb.append(", ");
+ sb.append("attributes:");
+ if (this.attributes == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.attributes);
+ }
+ first = false;
+ }
+ if (isSetDurability()) {
+ if (!first) sb.append(", ");
+ sb.append("durability:");
+ if (this.durability == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.durability);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (tableName == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tableName' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ if (tableName != null) {
+ tableName.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TTableDescriptorStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TTableDescriptorStandardScheme getScheme() {
+ return new TTableDescriptorStandardScheme();
+ }
+ }
+
+ private static class TTableDescriptorStandardScheme extends org.apache.thrift.scheme.StandardScheme<TTableDescriptor> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TTableDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // COLUMNS
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list162 = iprot.readListBegin();
+ struct.columns = new java.util.ArrayList<TColumnFamilyDescriptor>(_list162.size);
+ @org.apache.thrift.annotation.Nullable TColumnFamilyDescriptor _elem163;
+ for (int _i164 = 0; _i164 < _list162.size; ++_i164)
+ {
+ _elem163 = new TColumnFamilyDescriptor();
+ _elem163.read(iprot);
+ struct.columns.add(_elem163);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColumnsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // ATTRIBUTES
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
+ {
+ org.apache.thrift.protocol.TMap _map165 = iprot.readMapBegin();
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map165.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key166;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val167;
+ for (int _i168 = 0; _i168 < _map165.size; ++_i168)
+ {
+ _key166 = iprot.readBinary();
+ _val167 = iprot.readBinary();
+ struct.attributes.put(_key166, _val167);
+ }
+ iprot.readMapEnd();
+ }
+ struct.setAttributesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // DURABILITY
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TTableDescriptor struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ struct.tableName.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.columns != null) {
+ if (struct.isSetColumns()) {
+ oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+ for (TColumnFamilyDescriptor _iter169 : struct.columns)
+ {
+ _iter169.write(oprot);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.attributes != null) {
+ if (struct.isSetAttributes()) {
+ oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+ {
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size()));
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter170 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter170.getKey());
+ oprot.writeBinary(_iter170.getValue());
+ }
+ oprot.writeMapEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.durability != null) {
+ if (struct.isSetDurability()) {
+ oprot.writeFieldBegin(DURABILITY_FIELD_DESC);
+ oprot.writeI32(struct.durability.getValue());
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TTableDescriptorTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TTableDescriptorTupleScheme getScheme() {
+ return new TTableDescriptorTupleScheme();
+ }
+ }
+
+ private static class TTableDescriptorTupleScheme extends org.apache.thrift.scheme.TupleScheme<TTableDescriptor> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TTableDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName.write(oprot);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetColumns()) {
+ optionals.set(0);
+ }
+ if (struct.isSetAttributes()) {
+ optionals.set(1);
+ }
+ if (struct.isSetDurability()) {
+ optionals.set(2);
+ }
+ oprot.writeBitSet(optionals, 3);
+ if (struct.isSetColumns()) {
+ {
+ oprot.writeI32(struct.columns.size());
+ for (TColumnFamilyDescriptor _iter171 : struct.columns)
+ {
+ _iter171.write(oprot);
+ }
+ }
+ }
+ if (struct.isSetAttributes()) {
+ {
+ oprot.writeI32(struct.attributes.size());
+ for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter172 : struct.attributes.entrySet())
+ {
+ oprot.writeBinary(_iter172.getKey());
+ oprot.writeBinary(_iter172.getValue());
+ }
+ }
+ }
+ if (struct.isSetDurability()) {
+ oprot.writeI32(struct.durability.getValue());
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TTableDescriptor struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.tableName = new TTableName();
+ struct.tableName.read(iprot);
+ struct.setTableNameIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(3);
+ if (incoming.get(0)) {
+ {
+ org.apache.thrift.protocol.TList _list173 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT);
+ struct.columns = new java.util.ArrayList<TColumnFamilyDescriptor>(_list173.size);
+ @org.apache.thrift.annotation.Nullable TColumnFamilyDescriptor _elem174;
+ for (int _i175 = 0; _i175 < _list173.size; ++_i175)
+ {
+ _elem174 = new TColumnFamilyDescriptor();
+ _elem174.read(iprot);
+ struct.columns.add(_elem174);
+ }
+ }
+ struct.setColumnsIsSet(true);
+ }
+ if (incoming.get(1)) {
+ {
+ org.apache.thrift.protocol.TMap _map176 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map176.size);
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key177;
+ @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val178;
+ for (int _i179 = 0; _i179 < _map176.size; ++_i179)
+ {
+ _key177 = iprot.readBinary();
+ _val178 = iprot.readBinary();
+ struct.attributes.put(_key177, _val178);
+ }
+ }
+ struct.setAttributesIsSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.durability = org.apache.hadoop.hbase.thrift2.generated.TDurability.findByValue(iprot.readI32());
+ struct.setDurabilityIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableName.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableName.java
new file mode 100644
index 0000000..80ae046
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableName.java
@@ -0,0 +1,533 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.TableName
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TTableName implements org.apache.thrift.TBase<TTableName, TTableName._Fields>, java.io.Serializable, Cloneable, Comparable<TTableName> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTableName");
+
+ private static final org.apache.thrift.protocol.TField NS_FIELD_DESC = new org.apache.thrift.protocol.TField("ns", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TTableNameStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TTableNameTupleSchemeFactory();
+
+ /**
+ * namespace name
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer ns; // optional
+ /**
+ * tablename
+ */
+ public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ /**
+ * namespace name
+ */
+ NS((short)1, "ns"),
+ /**
+ * tablename
+ */
+ QUALIFIER((short)2, "qualifier");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // NS
+ return NS;
+ case 2: // QUALIFIER
+ return QUALIFIER;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final _Fields optionals[] = {_Fields.NS};
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NS, new org.apache.thrift.meta_data.FieldMetaData("ns", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TTableName.class, metaDataMap);
+ }
+
+ public TTableName() {
+ }
+
+ public TTableName(
+ java.nio.ByteBuffer qualifier)
+ {
+ this();
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TTableName(TTableName other) {
+ if (other.isSetNs()) {
+ this.ns = org.apache.thrift.TBaseHelper.copyBinary(other.ns);
+ }
+ if (other.isSetQualifier()) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
+ }
+ }
+
+ public TTableName deepCopy() {
+ return new TTableName(this);
+ }
+
+ @Override
+ public void clear() {
+ this.ns = null;
+ this.qualifier = null;
+ }
+
+ /**
+ * namespace name
+ */
+ public byte[] getNs() {
+ setNs(org.apache.thrift.TBaseHelper.rightSize(ns));
+ return ns == null ? null : ns.array();
+ }
+
+ public java.nio.ByteBuffer bufferForNs() {
+ return org.apache.thrift.TBaseHelper.copyBinary(ns);
+ }
+
+ /**
+ * namespace name
+ */
+ public TTableName setNs(byte[] ns) {
+ this.ns = ns == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(ns.clone());
+ return this;
+ }
+
+ public TTableName setNs(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer ns) {
+ this.ns = org.apache.thrift.TBaseHelper.copyBinary(ns);
+ return this;
+ }
+
+ public void unsetNs() {
+ this.ns = null;
+ }
+
+ /** Returns true if field ns is set (has been assigned a value) and false otherwise */
+ public boolean isSetNs() {
+ return this.ns != null;
+ }
+
+ public void setNsIsSet(boolean value) {
+ if (!value) {
+ this.ns = null;
+ }
+ }
+
+ /**
+ * tablename
+ */
+ public byte[] getQualifier() {
+ setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
+ return qualifier == null ? null : qualifier.array();
+ }
+
+ public java.nio.ByteBuffer bufferForQualifier() {
+ return org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ }
+
+ /**
+ * tablename
+ */
+ public TTableName setQualifier(byte[] qualifier) {
+ this.qualifier = qualifier == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(qualifier.clone());
+ return this;
+ }
+
+ public TTableName setQualifier(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer qualifier) {
+ this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(qualifier);
+ return this;
+ }
+
+ public void unsetQualifier() {
+ this.qualifier = null;
+ }
+
+ /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
+ public boolean isSetQualifier() {
+ return this.qualifier != null;
+ }
+
+ public void setQualifierIsSet(boolean value) {
+ if (!value) {
+ this.qualifier = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case NS:
+ if (value == null) {
+ unsetNs();
+ } else {
+ if (value instanceof byte[]) {
+ setNs((byte[])value);
+ } else {
+ setNs((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ case QUALIFIER:
+ if (value == null) {
+ unsetQualifier();
+ } else {
+ if (value instanceof byte[]) {
+ setQualifier((byte[])value);
+ } else {
+ setQualifier((java.nio.ByteBuffer)value);
+ }
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NS:
+ return getNs();
+
+ case QUALIFIER:
+ return getQualifier();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NS:
+ return isSetNs();
+ case QUALIFIER:
+ return isSetQualifier();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TTableName)
+ return this.equals((TTableName)that);
+ return false;
+ }
+
+ public boolean equals(TTableName that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_ns = true && this.isSetNs();
+ boolean that_present_ns = true && that.isSetNs();
+ if (this_present_ns || that_present_ns) {
+ if (!(this_present_ns && that_present_ns))
+ return false;
+ if (!this.ns.equals(that.ns))
+ return false;
+ }
+
+ boolean this_present_qualifier = true && this.isSetQualifier();
+ boolean that_present_qualifier = true && that.isSetQualifier();
+ if (this_present_qualifier || that_present_qualifier) {
+ if (!(this_present_qualifier && that_present_qualifier))
+ return false;
+ if (!this.qualifier.equals(that.qualifier))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetNs()) ? 131071 : 524287);
+ if (isSetNs())
+ hashCode = hashCode * 8191 + ns.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetQualifier()) ? 131071 : 524287);
+ if (isSetQualifier())
+ hashCode = hashCode * 8191 + qualifier.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TTableName other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetNs(), other.isSetNs());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNs()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ns, other.ns);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetQualifier(), other.isSetQualifier());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQualifier()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, other.qualifier);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TTableName(");
+ boolean first = true;
+
+ if (isSetNs()) {
+ sb.append("ns:");
+ if (this.ns == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.ns, sb);
+ }
+ first = false;
+ }
+ if (!first) sb.append(", ");
+ sb.append("qualifier:");
+ if (this.qualifier == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (qualifier == null) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
+ }
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TTableNameStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TTableNameStandardScheme getScheme() {
+ return new TTableNameStandardScheme();
+ }
+ }
+
+ private static class TTableNameStandardScheme extends org.apache.thrift.scheme.StandardScheme<TTableName> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TTableName struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // NS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.ns = iprot.readBinary();
+ struct.setNsIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // QUALIFIER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TTableName struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.ns != null) {
+ if (struct.isSetNs()) {
+ oprot.writeFieldBegin(NS_FIELD_DESC);
+ oprot.writeBinary(struct.ns);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.qualifier != null) {
+ oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
+ oprot.writeBinary(struct.qualifier);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TTableNameTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TTableNameTupleScheme getScheme() {
+ return new TTableNameTupleScheme();
+ }
+ }
+
+ private static class TTableNameTupleScheme extends org.apache.thrift.scheme.TupleScheme<TTableName> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TTableName struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeBinary(struct.qualifier);
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetNs()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetNs()) {
+ oprot.writeBinary(struct.ns);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TTableName struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.qualifier = iprot.readBinary();
+ struct.setQualifierIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.ns = iprot.readBinary();
+ struct.setNsIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TThriftServerType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TThriftServerType.java
new file mode 100644
index 0000000..722b0f5
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TThriftServerType.java
@@ -0,0 +1,46 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+
+/**
+ * Specify type of thrift server: thrift and thrift2
+ */
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public enum TThriftServerType implements org.apache.thrift.TEnum {
+ ONE(1),
+ TWO(2);
+
+ private final int value;
+
+ private TThriftServerType(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static TThriftServerType findByValue(int value) {
+ switch (value) {
+ case 1:
+ return ONE;
+ case 2:
+ return TWO;
+ default:
+ return null;
+ }
+ }
+}
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java
new file mode 100644
index 0000000..fefa7cb
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java
@@ -0,0 +1,457 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hbase.thrift2.generated;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2021-07-19")
+public class TTimeRange implements org.apache.thrift.TBase<TTimeRange, TTimeRange._Fields>, java.io.Serializable, Cloneable, Comparable<TTimeRange> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTimeRange");
+
+ private static final org.apache.thrift.protocol.TField MIN_STAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("minStamp", org.apache.thrift.protocol.TType.I64, (short)1);
+ private static final org.apache.thrift.protocol.TField MAX_STAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("maxStamp", org.apache.thrift.protocol.TType.I64, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TTimeRangeStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TTimeRangeTupleSchemeFactory();
+
+ public long minStamp; // required
+ public long maxStamp; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ MIN_STAMP((short)1, "minStamp"),
+ MAX_STAMP((short)2, "maxStamp");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // MIN_STAMP
+ return MIN_STAMP;
+ case 2: // MAX_STAMP
+ return MAX_STAMP;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __MINSTAMP_ISSET_ID = 0;
+ private static final int __MAXSTAMP_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.MIN_STAMP, new org.apache.thrift.meta_data.FieldMetaData("minStamp", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ tmpMap.put(_Fields.MAX_STAMP, new org.apache.thrift.meta_data.FieldMetaData("maxStamp", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TTimeRange.class, metaDataMap);
+ }
+
+ public TTimeRange() {
+ }
+
+ public TTimeRange(
+ long minStamp,
+ long maxStamp)
+ {
+ this();
+ this.minStamp = minStamp;
+ setMinStampIsSet(true);
+ this.maxStamp = maxStamp;
+ setMaxStampIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TTimeRange(TTimeRange other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.minStamp = other.minStamp;
+ this.maxStamp = other.maxStamp;
+ }
+
+ public TTimeRange deepCopy() {
+ return new TTimeRange(this);
+ }
+
+ @Override
+ public void clear() {
+ setMinStampIsSet(false);
+ this.minStamp = 0;
+ setMaxStampIsSet(false);
+ this.maxStamp = 0;
+ }
+
+ public long getMinStamp() {
+ return this.minStamp;
+ }
+
+ public TTimeRange setMinStamp(long minStamp) {
+ this.minStamp = minStamp;
+ setMinStampIsSet(true);
+ return this;
+ }
+
+ public void unsetMinStamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MINSTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field minStamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetMinStamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MINSTAMP_ISSET_ID);
+ }
+
+ public void setMinStampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MINSTAMP_ISSET_ID, value);
+ }
+
+ public long getMaxStamp() {
+ return this.maxStamp;
+ }
+
+ public TTimeRange setMaxStamp(long maxStamp) {
+ this.maxStamp = maxStamp;
+ setMaxStampIsSet(true);
+ return this;
+ }
+
+ public void unsetMaxStamp() {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __MAXSTAMP_ISSET_ID);
+ }
+
+ /** Returns true if field maxStamp is set (has been assigned a value) and false otherwise */
+ public boolean isSetMaxStamp() {
+ return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MAXSTAMP_ISSET_ID);
+ }
+
+ public void setMaxStampIsSet(boolean value) {
+ __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MAXSTAMP_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case MIN_STAMP:
+ if (value == null) {
+ unsetMinStamp();
+ } else {
+ setMinStamp((java.lang.Long)value);
+ }
+ break;
+
+ case MAX_STAMP:
+ if (value == null) {
+ unsetMaxStamp();
+ } else {
+ setMaxStamp((java.lang.Long)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MIN_STAMP:
+ return getMinStamp();
+
+ case MAX_STAMP:
+ return getMaxStamp();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case MIN_STAMP:
+ return isSetMinStamp();
+ case MAX_STAMP:
+ return isSetMaxStamp();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TTimeRange)
+ return this.equals((TTimeRange)that);
+ return false;
+ }
+
+ public boolean equals(TTimeRange that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_minStamp = true;
+ boolean that_present_minStamp = true;
+ if (this_present_minStamp || that_present_minStamp) {
+ if (!(this_present_minStamp && that_present_minStamp))
+ return false;
+ if (this.minStamp != that.minStamp)
+ return false;
+ }
+
+ boolean this_present_maxStamp = true;
+ boolean that_present_maxStamp = true;
+ if (this_present_maxStamp || that_present_maxStamp) {
+ if (!(this_present_maxStamp && that_present_maxStamp))
+ return false;
+ if (this.maxStamp != that.maxStamp)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(minStamp);
+
+ hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(maxStamp);
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TTimeRange other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetMinStamp(), other.isSetMinStamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMinStamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.minStamp, other.minStamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetMaxStamp(), other.isSetMaxStamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMaxStamp()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxStamp, other.maxStamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TTimeRange(");
+ boolean first = true;
+
+ sb.append("minStamp:");
+ sb.append(this.minStamp);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("maxStamp:");
+ sb.append(this.maxStamp);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // alas, we cannot check 'minStamp' because it's a primitive and you chose the non-beans generator.
+ // alas, we cannot check 'maxStamp' because it's a primitive and you chose the non-beans generator.
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TTimeRangeStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TTimeRangeStandardScheme getScheme() {
+ return new TTimeRangeStandardScheme();
+ }
+ }
+
+ private static class TTimeRangeStandardScheme extends org.apache.thrift.scheme.StandardScheme<TTimeRange> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TTimeRange struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // MIN_STAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.minStamp = iprot.readI64();
+ struct.setMinStampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // MAX_STAMP
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.maxStamp = iprot.readI64();
+ struct.setMaxStampIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ if (!struct.isSetMinStamp()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'minStamp' was not found in serialized data! Struct: " + toString());
+ }
+ if (!struct.isSetMaxStamp()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'maxStamp' was not found in serialized data! Struct: " + toString());
+ }
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TTimeRange struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(MIN_STAMP_FIELD_DESC);
+ oprot.writeI64(struct.minStamp);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(MAX_STAMP_FIELD_DESC);
+ oprot.writeI64(struct.maxStamp);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TTimeRangeTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TTimeRangeTupleScheme getScheme() {
+ return new TTimeRangeTupleScheme();
+ }
+ }
+
+ private static class TTimeRangeTupleScheme extends org.apache.thrift.scheme.TupleScheme<TTimeRange> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TTimeRange struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ oprot.writeI64(struct.minStamp);
+ oprot.writeI64(struct.maxStamp);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TTimeRange struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.minStamp = iprot.readI64();
+ struct.setMinStampIsSet(true);
+ struct.maxStamp = iprot.readI64();
+ struct.setMaxStampIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/package.html b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/package.html
new file mode 100644
index 0000000..5c7ca94
--- /dev/null
+++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/package.html
@@ -0,0 +1,103 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<html>
+
+<!--
+ 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.
+-->
+
+<head />
+<body bgcolor="white">
+Provides an HBase <a href="http://thrift.apache.org/">Thrift</a>
+service.
+
+This package contains a Thrift interface definition file for an HBase RPC
+service and a Java server implementation.
+
+There are currently 2 thrift server implementations in HBase, the packages:
+
+<ul>
+ <li>org.apache.hadoop.hbase.thrift: This may one day be marked as depreceated.</li>
+ <li>org.apache.hadoop.hbase.thrift2: i.e. this package. This is intended to closely match to the HTable interface and
+ to one day supercede the older thrift (the old thrift mimics an API HBase no longer has).</li>
+</ul>
+
+<h2><a name="whatisthrift">What is Thrift?</a></h2>
+
+
+<p>"Thrift is a software framework for scalable cross-language services
+development. It combines a software stack with a code generation engine to
+build services that work efficiently and seamlessly between C++, Java, Python,
+PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk,
+and OCaml. Originally developed at Facebook, Thrift was open sourced in April
+2007 and entered the Apache Incubator in May, 2008".
+From http://thrift.apache.org/</p>
+
+<h2><a name="description">Description</a></h2>
+
+<p>The HBase API is defined in the
+file hbase.thrift. A server-side implementation of the API is in
+<code>org.apache.hadoop.hbase.thrift2.ThriftHBaseServiceHandler</code> with the
+server boiler plate in <code>org.apache.hadoop.hbase.thrift2.ThriftServer</code>.
+The generated interfaces, types, and RPC utility files are checked into SVN under the
+<code>org.apache.hadoop.hbase.thrift2.generated</code> directory.
+</p>
+<p>To stop, use:
+<pre>
+ ./bin/hbase-daemon.sh stop thrift2
+</pre>
+
+These are the command line arguments the Thrift server understands in addition to <code>start</code> and <code>stop</code>:
+<dl>
+ <dt><code>-b, --bind</code></dt>
+ <dd>Address to bind the Thrift server to. Not supported by the Nonblocking and HsHa server [default: <code>0.0.0.0</code>]</dd>
+
+ <dt><code>-p, --port</code></dt>
+ <dd>Port to bind to [default: <code>9090</code>]</dd>
+
+ <dt><code>-f, --framed</code></dt>
+ <dd>Use framed transport (implied when using one of the non-blocking servers)</dd>
+
+ <dt><code>-c, --compact</code></dt>
+ <dd>Use the compact protocol [default: binary protocol]</dd>
+
+ <dt><code>-h, --help</code></dt>
+ <dd>Displays usage information for the Thrift server</dd>
+
+ <dt><code>-threadpool</code></dt>
+ <dd>Use the TThreadPoolServer. This is the default.</dd>
+
+ <dt><code>-hsha</code></dt>
+ <dd>Use the THsHaServer. This implies the framed transport.</dd>
+
+ <dt><code>-nonblocking</code></dt>
+ <dd>Use the TNonblockingServer. This implies the framed transport.</dd>
+</dl>
+
+<h3><a name="details">Details</a></h3>
+
+<p>HBase currently uses version 0.9.0 of Apache Thrift.</p>
+<p>The files were generated by running the commands under the hbase checkout dir:
+<pre>
+ mvn compile -Pcompile-thrift
+</pre>
+
+<p>The 'thrift' binary is the Thrift compiler, and it is distributed separately from HBase
+in a Thrift release. Additionally, specific language runtime libraries are a
+part of a Thrift release. A version of the Java runtime is included in HBase via maven.
+</p>
+
+</body>
+</html>
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/css/bootstrap-theme.min.css b/hbase-thrift/src/main/resources/hbase-webapps/static/css/bootstrap-theme.min.css
new file mode 100644
index 0000000..2a69f48
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/css/bootstrap-theme.min.css
@@ -0,0 +1,6 @@
+/*!
+ * Bootstrap v3.4.1 (https://getbootstrap.com/)
+ * Copyright 2011-2019 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ */.btn-danger,.btn-default,.btn-info,.btn-primary,.btn-success,.btn-warning{text-shadow:0 -1px 0 rgba(0,0,0,.2);-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.15),0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 0 rgba(255,255,255,.15),0 1px 1px rgba(0,0,0,.075)}.btn-danger.active,.btn-danger:active,.btn-default.active,.btn-default:active,.btn-info.active,.btn-info:active,.btn-primary.active,.btn-primary:active,.btn-success.active,.btn-success:active,.btn-warning.active,.btn-warning:active{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-danger.disabled,.btn-danger[disabled],.btn-default.disabled,.btn-default[disabled],.btn-info.disabled,.btn-info[disabled],.btn-primary.disabled,.btn-primary[disabled],.btn-success.disabled,.btn-success[disabled],.btn-warning.disabled,.btn-warning[disabled],fieldset[disabled] .btn-danger,fieldset[disabled] .btn-default,fieldset[disabled] .btn-info,fieldset[disabled] .btn-primary,fieldset[disabled] .btn-success,fieldset[disabled] .btn-warning{-webkit-box-shadow:none;box-shadow:none}.btn-danger .badge,.btn-default .badge,.btn-info .badge,.btn-primary .badge,.btn-success .badge,.btn-warning .badge{text-shadow:none}.btn.active,.btn:active{background-image:none}.btn-default{background-image:-webkit-linear-gradient(top,#fff 0,#e0e0e0 100%);background-image:-o-linear-gradient(top,#fff 0,#e0e0e0 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#fff),to(#e0e0e0));background-image:linear-gradient(to bottom,#fff 0,#e0e0e0 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe0e0e0', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#dbdbdb;text-shadow:0 1px 0 #fff;border-color:#ccc}.btn-default:focus,.btn-default:hover{background-color:#e0e0e0;background-position:0 -15px}.btn-default.active,.btn-default:active{background-color:#e0e0e0;border-color:#dbdbdb}.btn-default.disabled,.btn-default.disabled.active,.btn-default.disabled.focus,.btn-default.disabled:active,.btn-default.disabled:focus,.btn-default.disabled:hover,.btn-default[disabled],.btn-default[disabled].active,.btn-default[disabled].focus,.btn-default[disabled]:active,.btn-default[disabled]:focus,.btn-default[disabled]:hover,fieldset[disabled] .btn-default,fieldset[disabled] .btn-default.active,fieldset[disabled] .btn-default.focus,fieldset[disabled] .btn-default:active,fieldset[disabled] .btn-default:focus,fieldset[disabled] .btn-default:hover{background-color:#e0e0e0;background-image:none}.btn-primary{background-image:-webkit-linear-gradient(top,#337ab7 0,#265a88 100%);background-image:-o-linear-gradient(top,#337ab7 0,#265a88 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#337ab7),to(#265a88));background-image:linear-gradient(to bottom,#337ab7 0,#265a88 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff265a88', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#245580}.btn-primary:focus,.btn-primary:hover{background-color:#265a88;background-position:0 -15px}.btn-primary.active,.btn-primary:active{background-color:#265a88;border-color:#245580}.btn-primary.disabled,.btn-primary.disabled.active,.btn-primary.disabled.focus,.btn-primary.disabled:active,.btn-primary.disabled:focus,.btn-primary.disabled:hover,.btn-primary[disabled],.btn-primary[disabled].active,.btn-primary[disabled].focus,.btn-primary[disabled]:active,.btn-primary[disabled]:focus,.btn-primary[disabled]:hover,fieldset[disabled] .btn-primary,fieldset[disabled] .btn-primary.active,fieldset[disabled] .btn-primary.focus,fieldset[disabled] .btn-primary:active,fieldset[disabled] .btn-primary:focus,fieldset[disabled] .btn-primary:hover{background-color:#265a88;background-image:none}.btn-success{background-image:-webkit-linear-gradient(top,#5cb85c 0,#419641 100%);background-image:-o-linear-gradient(top,#5cb85c 0,#419641 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#5cb85c),to(#419641));background-image:linear-gradient(to bottom,#5cb85c 0,#419641 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff419641', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#3e8f3e}.btn-success:focus,.btn-success:hover{background-color:#419641;background-position:0 -15px}.btn-success.active,.btn-success:active{background-color:#419641;border-color:#3e8f3e}.btn-success.disabled,.btn-success.disabled.active,.btn-success.disabled.focus,.btn-success.disabled:active,.btn-success.disabled:focus,.btn-success.disabled:hover,.btn-success[disabled],.btn-success[disabled].active,.btn-success[disabled].focus,.btn-success[disabled]:active,.btn-success[disabled]:focus,.btn-success[disabled]:hover,fieldset[disabled] .btn-success,fieldset[disabled] .btn-success.active,fieldset[disabled] .btn-success.focus,fieldset[disabled] .btn-success:active,fieldset[disabled] .btn-success:focus,fieldset[disabled] .btn-success:hover{background-color:#419641;background-image:none}.btn-info{background-image:-webkit-linear-gradient(top,#5bc0de 0,#2aabd2 100%);background-image:-o-linear-gradient(top,#5bc0de 0,#2aabd2 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#5bc0de),to(#2aabd2));background-image:linear-gradient(to bottom,#5bc0de 0,#2aabd2 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2aabd2', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#28a4c9}.btn-info:focus,.btn-info:hover{background-color:#2aabd2;background-position:0 -15px}.btn-info.active,.btn-info:active{background-color:#2aabd2;border-color:#28a4c9}.btn-info.disabled,.btn-info.disabled.active,.btn-info.disabled.focus,.btn-info.disabled:active,.btn-info.disabled:focus,.btn-info.disabled:hover,.btn-info[disabled],.btn-info[disabled].active,.btn-info[disabled].focus,.btn-info[disabled]:active,.btn-info[disabled]:focus,.btn-info[disabled]:hover,fieldset[disabled] .btn-info,fieldset[disabled] .btn-info.active,fieldset[disabled] .btn-info.focus,fieldset[disabled] .btn-info:active,fieldset[disabled] .btn-info:focus,fieldset[disabled] .btn-info:hover{background-color:#2aabd2;background-image:none}.btn-warning{background-image:-webkit-linear-gradient(top,#f0ad4e 0,#eb9316 100%);background-image:-o-linear-gradient(top,#f0ad4e 0,#eb9316 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#f0ad4e),to(#eb9316));background-image:linear-gradient(to bottom,#f0ad4e 0,#eb9316 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffeb9316', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#e38d13}.btn-warning:focus,.btn-warning:hover{background-color:#eb9316;background-position:0 -15px}.btn-warning.active,.btn-warning:active{background-color:#eb9316;border-color:#e38d13}.btn-warning.disabled,.btn-warning.disabled.active,.btn-warning.disabled.focus,.btn-warning.disabled:active,.btn-warning.disabled:focus,.btn-warning.disabled:hover,.btn-warning[disabled],.btn-warning[disabled].active,.btn-warning[disabled].focus,.btn-warning[disabled]:active,.btn-warning[disabled]:focus,.btn-warning[disabled]:hover,fieldset[disabled] .btn-warning,fieldset[disabled] .btn-warning.active,fieldset[disabled] .btn-warning.focus,fieldset[disabled] .btn-warning:active,fieldset[disabled] .btn-warning:focus,fieldset[disabled] .btn-warning:hover{background-color:#eb9316;background-image:none}.btn-danger{background-image:-webkit-linear-gradient(top,#d9534f 0,#c12e2a 100%);background-image:-o-linear-gradient(top,#d9534f 0,#c12e2a 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#d9534f),to(#c12e2a));background-image:linear-gradient(to bottom,#d9534f 0,#c12e2a 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc12e2a', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#b92c28}.btn-danger:focus,.btn-danger:hover{background-color:#c12e2a;background-position:0 -15px}.btn-danger.active,.btn-danger:active{background-color:#c12e2a;border-color:#b92c28}.btn-danger.disabled,.btn-danger.disabled.active,.btn-danger.disabled.focus,.btn-danger.disabled:active,.btn-danger.disabled:focus,.btn-danger.disabled:hover,.btn-danger[disabled],.btn-danger[disabled].active,.btn-danger[disabled].focus,.btn-danger[disabled]:active,.btn-danger[disabled]:focus,.btn-danger[disabled]:hover,fieldset[disabled] .btn-danger,fieldset[disabled] .btn-danger.active,fieldset[disabled] .btn-danger.focus,fieldset[disabled] .btn-danger:active,fieldset[disabled] .btn-danger:focus,fieldset[disabled] .btn-danger:hover{background-color:#c12e2a;background-image:none}.img-thumbnail,.thumbnail{-webkit-box-shadow:0 1px 2px rgba(0,0,0,.075);box-shadow:0 1px 2px rgba(0,0,0,.075)}.dropdown-menu>li>a:focus,.dropdown-menu>li>a:hover{background-image:-webkit-linear-gradient(top,#f5f5f5 0,#e8e8e8 100%);background-image:-o-linear-gradient(top,#f5f5f5 0,#e8e8e8 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#f5f5f5),to(#e8e8e8));background-image:linear-gradient(to bottom,#f5f5f5 0,#e8e8e8 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);background-repeat:repeat-x;background-color:#e8e8e8}.dropdown-menu>.active>a,.dropdown-menu>.active>a:focus,.dropdown-menu>.active>a:hover{background-image:-webkit-linear-gradient(top,#337ab7 0,#2e6da4 100%);background-image:-o-linear-gradient(top,#337ab7 0,#2e6da4 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#337ab7),to(#2e6da4));background-image:linear-gradient(to bottom,#337ab7 0,#2e6da4 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);background-repeat:repeat-x;background-color:#2e6da4}.navbar-default{background-image:-webkit-linear-gradient(top,#fff 0,#f8f8f8 100%);background-image:-o-linear-gradient(top,#fff 0,#f8f8f8 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#fff),to(#f8f8f8));background-image:linear-gradient(to bottom,#fff 0,#f8f8f8 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff8f8f8', GradientType=0);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);border-radius:4px;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.15),0 1px 5px rgba(0,0,0,.075);box-shadow:inset 0 1px 0 rgba(255,255,255,.15),0 1px 5px rgba(0,0,0,.075)}.navbar-default .navbar-nav>.active>a,.navbar-default .navbar-nav>.open>a{background-image:-webkit-linear-gradient(top,#dbdbdb 0,#e2e2e2 100%);background-image:-o-linear-gradient(top,#dbdbdb 0,#e2e2e2 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#dbdbdb),to(#e2e2e2));background-image:linear-gradient(to bottom,#dbdbdb 0,#e2e2e2 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdbdbdb', endColorstr='#ffe2e2e2', GradientType=0);background-repeat:repeat-x;-webkit-box-shadow:inset 0 3px 9px rgba(0,0,0,.075);box-shadow:inset 0 3px 9px rgba(0,0,0,.075)}.navbar-brand,.navbar-nav>li>a{text-shadow:0 1px 0 rgba(255,255,255,.25)}.navbar-inverse{background-image:-webkit-linear-gradient(top,#3c3c3c 0,#222 100%);background-image:-o-linear-gradient(top,#3c3c3c 0,#222 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#3c3c3c),to(#222));background-image:linear-gradient(to bottom,#3c3c3c 0,#222 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff3c3c3c', endColorstr='#ff222222', GradientType=0);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);border-radius:4px}.navbar-inverse .navbar-nav>.active>a,.navbar-inverse .navbar-nav>.open>a{background-image:-webkit-linear-gradient(top,#080808 0,#0f0f0f 100%);background-image:-o-linear-gradient(top,#080808 0,#0f0f0f 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#080808),to(#0f0f0f));background-image:linear-gradient(to bottom,#080808 0,#0f0f0f 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff080808', endColorstr='#ff0f0f0f', GradientType=0);background-repeat:repeat-x;-webkit-box-shadow:inset 0 3px 9px rgba(0,0,0,.25);box-shadow:inset 0 3px 9px rgba(0,0,0,.25)}.navbar-inverse .navbar-brand,.navbar-inverse .navbar-nav>li>a{text-shadow:0 -1px 0 rgba(0,0,0,.25)}.navbar-fixed-bottom,.navbar-fixed-top,.navbar-static-top{border-radius:0}@media (max-width:767px){.navbar .navbar-nav .open .dropdown-menu>.active>a,.navbar .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar .navbar-nav .open .dropdown-menu>.active>a:hover{color:#fff;background-image:-webkit-linear-gradient(top,#337ab7 0,#2e6da4 100%);background-image:-o-linear-gradient(top,#337ab7 0,#2e6da4 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#337ab7),to(#2e6da4));background-image:linear-gradient(to bottom,#337ab7 0,#2e6da4 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);background-repeat:repeat-x}}.alert{text-shadow:0 1px 0 rgba(255,255,255,.2);-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.25),0 1px 2px rgba(0,0,0,.05);box-shadow:inset 0 1px 0 rgba(255,255,255,.25),0 1px 2px rgba(0,0,0,.05)}.alert-success{background-image:-webkit-linear-gradient(top,#dff0d8 0,#c8e5bc 100%);background-image:-o-linear-gradient(top,#dff0d8 0,#c8e5bc 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#dff0d8),to(#c8e5bc));background-image:linear-gradient(to bottom,#dff0d8 0,#c8e5bc 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffc8e5bc', GradientType=0);background-repeat:repeat-x;border-color:#b2dba1}.alert-info{background-image:-webkit-linear-gradient(top,#d9edf7 0,#b9def0 100%);background-image:-o-linear-gradient(top,#d9edf7 0,#b9def0 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#d9edf7),to(#b9def0));background-image:linear-gradient(to bottom,#d9edf7 0,#b9def0 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffb9def0', GradientType=0);background-repeat:repeat-x;border-color:#9acfea}.alert-warning{background-image:-webkit-linear-gradient(top,#fcf8e3 0,#f8efc0 100%);background-image:-o-linear-gradient(top,#fcf8e3 0,#f8efc0 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#fcf8e3),to(#f8efc0));background-image:linear-gradient(to bottom,#fcf8e3 0,#f8efc0 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fff8efc0', GradientType=0);background-repeat:repeat-x;border-color:#f5e79e}.alert-danger{background-image:-webkit-linear-gradient(top,#f2dede 0,#e7c3c3 100%);background-image:-o-linear-gradient(top,#f2dede 0,#e7c3c3 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#f2dede),to(#e7c3c3));background-image:linear-gradient(to bottom,#f2dede 0,#e7c3c3 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffe7c3c3', GradientType=0);background-repeat:repeat-x;border-color:#dca7a7}.progress{background-image:-webkit-linear-gradient(top,#ebebeb 0,#f5f5f5 100%);background-image:-o-linear-gradient(top,#ebebeb 0,#f5f5f5 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#ebebeb),to(#f5f5f5));background-image:linear-gradient(to bottom,#ebebeb 0,#f5f5f5 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffebebeb', endColorstr='#fff5f5f5', GradientType=0);background-repeat:repeat-x}.progress-bar{background-image:-webkit-linear-gradient(top,#337ab7 0,#286090 100%);background-image:-o-linear-gradient(top,#337ab7 0,#286090 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#337ab7),to(#286090));background-image:linear-gradient(to bottom,#337ab7 0,#286090 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff286090', GradientType=0);background-repeat:repeat-x}.progress-bar-success{background-image:-webkit-linear-gradient(top,#5cb85c 0,#449d44 100%);background-image:-o-linear-gradient(top,#5cb85c 0,#449d44 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#5cb85c),to(#449d44));background-image:linear-gradient(to bottom,#5cb85c 0,#449d44 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff449d44', GradientType=0);background-repeat:repeat-x}.progress-bar-info{background-image:-webkit-linear-gradient(top,#5bc0de 0,#31b0d5 100%);background-image:-o-linear-gradient(top,#5bc0de 0,#31b0d5 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#5bc0de),to(#31b0d5));background-image:linear-gradient(to bottom,#5bc0de 0,#31b0d5 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff31b0d5', GradientType=0);background-repeat:repeat-x}.progress-bar-warning{background-image:-webkit-linear-gradient(top,#f0ad4e 0,#ec971f 100%);background-image:-o-linear-gradient(top,#f0ad4e 0,#ec971f 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#f0ad4e),to(#ec971f));background-image:linear-gradient(to bottom,#f0ad4e 0,#ec971f 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffec971f', GradientType=0);background-repeat:repeat-x}.progress-bar-danger{background-image:-webkit-linear-gradient(top,#d9534f 0,#c9302c 100%);background-image:-o-linear-gradient(top,#d9534f 0,#c9302c 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#d9534f),to(#c9302c));background-image:linear-gradient(to bottom,#d9534f 0,#c9302c 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc9302c', GradientType=0);background-repeat:repeat-x}.progress-bar-striped{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.list-group{border-radius:4px;-webkit-box-shadow:0 1px 2px rgba(0,0,0,.075);box-shadow:0 1px 2px rgba(0,0,0,.075)}.list-group-item.active,.list-group-item.active:focus,.list-group-item.active:hover{text-shadow:0 -1px 0 #286090;background-image:-webkit-linear-gradient(top,#337ab7 0,#2b669a 100%);background-image:-o-linear-gradient(top,#337ab7 0,#2b669a 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#337ab7),to(#2b669a));background-image:linear-gradient(to bottom,#337ab7 0,#2b669a 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2b669a', GradientType=0);background-repeat:repeat-x;border-color:#2b669a}.list-group-item.active .badge,.list-group-item.active:focus .badge,.list-group-item.active:hover .badge{text-shadow:none}.panel{-webkit-box-shadow:0 1px 2px rgba(0,0,0,.05);box-shadow:0 1px 2px rgba(0,0,0,.05)}.panel-default>.panel-heading{background-image:-webkit-linear-gradient(top,#f5f5f5 0,#e8e8e8 100%);background-image:-o-linear-gradient(top,#f5f5f5 0,#e8e8e8 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#f5f5f5),to(#e8e8e8));background-image:linear-gradient(to bottom,#f5f5f5 0,#e8e8e8 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);background-repeat:repeat-x}.panel-primary>.panel-heading{background-image:-webkit-linear-gradient(top,#337ab7 0,#2e6da4 100%);background-image:-o-linear-gradient(top,#337ab7 0,#2e6da4 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#337ab7),to(#2e6da4));background-image:linear-gradient(to bottom,#337ab7 0,#2e6da4 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);background-repeat:repeat-x}.panel-success>.panel-heading{background-image:-webkit-linear-gradient(top,#dff0d8 0,#d0e9c6 100%);background-image:-o-linear-gradient(top,#dff0d8 0,#d0e9c6 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#dff0d8),to(#d0e9c6));background-image:linear-gradient(to bottom,#dff0d8 0,#d0e9c6 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffd0e9c6', GradientType=0);background-repeat:repeat-x}.panel-info>.panel-heading{background-image:-webkit-linear-gradient(top,#d9edf7 0,#c4e3f3 100%);background-image:-o-linear-gradient(top,#d9edf7 0,#c4e3f3 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#d9edf7),to(#c4e3f3));background-image:linear-gradient(to bottom,#d9edf7 0,#c4e3f3 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffc4e3f3', GradientType=0);background-repeat:repeat-x}.panel-warning>.panel-heading{background-image:-webkit-linear-gradient(top,#fcf8e3 0,#faf2cc 100%);background-image:-o-linear-gradient(top,#fcf8e3 0,#faf2cc 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#fcf8e3),to(#faf2cc));background-image:linear-gradient(to bottom,#fcf8e3 0,#faf2cc 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fffaf2cc', GradientType=0);background-repeat:repeat-x}.panel-danger>.panel-heading{background-image:-webkit-linear-gradient(top,#f2dede 0,#ebcccc 100%);background-image:-o-linear-gradient(top,#f2dede 0,#ebcccc 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#f2dede),to(#ebcccc));background-image:linear-gradient(to bottom,#f2dede 0,#ebcccc 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffebcccc', GradientType=0);background-repeat:repeat-x}.well{background-image:-webkit-linear-gradient(top,#e8e8e8 0,#f5f5f5 100%);background-image:-o-linear-gradient(top,#e8e8e8 0,#f5f5f5 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#e8e8e8),to(#f5f5f5));background-image:linear-gradient(to bottom,#e8e8e8 0,#f5f5f5 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffe8e8e8', endColorstr='#fff5f5f5', GradientType=0);background-repeat:repeat-x;border-color:#dcdcdc;-webkit-box-shadow:inset 0 1px 3px rgba(0,0,0,.05),0 1px 0 rgba(255,255,255,.1);box-shadow:inset 0 1px 3px rgba(0,0,0,.05),0 1px 0 rgba(255,255,255,.1)}
+/*# sourceMappingURL=bootstrap-theme.min.css.map */
\ No newline at end of file
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/css/bootstrap.min.css b/hbase-thrift/src/main/resources/hbase-webapps/static/css/bootstrap.min.css
new file mode 100644
index 0000000..5b96335
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/css/bootstrap.min.css
@@ -0,0 +1,6 @@
+/*!
+ * Bootstrap v3.4.1 (https://getbootstrap.com/)
+ * Copyright 2011-2019 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ *//*! normalize.css v3.0.3 | MIT License | github.com/necolas/normalize.css */html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,menu,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background-color:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:none;text-decoration:underline;-webkit-text-decoration:underline dotted;-moz-text-decoration:underline dotted;text-decoration:underline dotted}b,strong{font-weight:700}dfn{font-style:italic}h1{font-size:2em;margin:.67em 0}mark{background:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;height:0}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0}button{overflow:visible}button,select{text-transform:none}button,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}input{line-height:normal}input[type=checkbox],input[type=radio]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:0}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{height:auto}input[type=search]{-webkit-appearance:textfield;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}legend{border:0;padding:0}textarea{overflow:auto}optgroup{font-weight:700}table{border-collapse:collapse;border-spacing:0}td,th{padding:0}/*! Source: https://github.com/h5bp/html5-boilerplate/blob/master/src/css/main.css */@media print{*,:after,:before{color:#000!important;text-shadow:none!important;background:0 0!important;-webkit-box-shadow:none!important;box-shadow:none!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}.navbar{display:none}.btn>.caret,.dropup>.btn>.caret{border-top-color:#000!important}.label{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered td,.table-bordered th{border:1px solid #ddd!important}}@font-face{font-family:"Glyphicons Halflings";src:url(../fonts/glyphicons-halflings-regular.eot);src:url(../fonts/glyphicons-halflings-regular.eot?#iefix) format("embedded-opentype"),url(../fonts/glyphicons-halflings-regular.woff2) format("woff2"),url(../fonts/glyphicons-halflings-regular.woff) format("woff"),url(../fonts/glyphicons-halflings-regular.ttf) format("truetype"),url(../fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular) format("svg")}.glyphicon{position:relative;top:1px;display:inline-block;font-family:"Glyphicons Halflings";font-style:normal;font-weight:400;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.glyphicon-asterisk:before{content:"\002a"}.glyphicon-plus:before{content:"\002b"}.glyphicon-eur:before,.glyphicon-euro:before{content:"\20ac"}.glyphicon-minus:before{content:"\2212"}.glyphicon-cloud:before{content:"\2601"}.glyphicon-envelope:before{content:"\2709"}.glyphicon-pencil:before{content:"\270f"}.glyphicon-glass:before{content:"\e001"}.glyphicon-music:before{content:"\e002"}.glyphicon-search:before{content:"\e003"}.glyphicon-heart:before{content:"\e005"}.glyphicon-star:before{content:"\e006"}.glyphicon-star-empty:before{content:"\e007"}.glyphicon-user:before{content:"\e008"}.glyphicon-film:before{content:"\e009"}.glyphicon-th-large:before{content:"\e010"}.glyphicon-th:before{content:"\e011"}.glyphicon-th-list:before{content:"\e012"}.glyphicon-ok:before{content:"\e013"}.glyphicon-remove:before{content:"\e014"}.glyphicon-zoom-in:before{content:"\e015"}.glyphicon-zoom-out:before{content:"\e016"}.glyphicon-off:before{content:"\e017"}.glyphicon-signal:before{content:"\e018"}.glyphicon-cog:before{content:"\e019"}.glyphicon-trash:before{content:"\e020"}.glyphicon-home:before{content:"\e021"}.glyphicon-file:before{content:"\e022"}.glyphicon-time:before{content:"\e023"}.glyphicon-road:before{content:"\e024"}.glyphicon-download-alt:before{content:"\e025"}.glyphicon-download:before{content:"\e026"}.glyphicon-upload:before{content:"\e027"}.glyphicon-inbox:before{content:"\e028"}.glyphicon-play-circle:before{content:"\e029"}.glyphicon-repeat:before{content:"\e030"}.glyphicon-refresh:before{content:"\e031"}.glyphicon-list-alt:before{content:"\e032"}.glyphicon-lock:before{content:"\e033"}.glyphicon-flag:before{content:"\e034"}.glyphicon-headphones:before{content:"\e035"}.glyphicon-volume-off:before{content:"\e036"}.glyphicon-volume-down:before{content:"\e037"}.glyphicon-volume-up:before{content:"\e038"}.glyphicon-qrcode:before{content:"\e039"}.glyphicon-barcode:before{content:"\e040"}.glyphicon-tag:before{content:"\e041"}.glyphicon-tags:before{content:"\e042"}.glyphicon-book:before{content:"\e043"}.glyphicon-bookmark:before{content:"\e044"}.glyphicon-print:before{content:"\e045"}.glyphicon-camera:before{content:"\e046"}.glyphicon-font:before{content:"\e047"}.glyphicon-bold:before{content:"\e048"}.glyphicon-italic:before{content:"\e049"}.glyphicon-text-height:before{content:"\e050"}.glyphicon-text-width:before{content:"\e051"}.glyphicon-align-left:before{content:"\e052"}.glyphicon-align-center:before{content:"\e053"}.glyphicon-align-right:before{content:"\e054"}.glyphicon-align-justify:before{content:"\e055"}.glyphicon-list:before{content:"\e056"}.glyphicon-indent-left:before{content:"\e057"}.glyphicon-indent-right:before{content:"\e058"}.glyphicon-facetime-video:before{content:"\e059"}.glyphicon-picture:before{content:"\e060"}.glyphicon-map-marker:before{content:"\e062"}.glyphicon-adjust:before{content:"\e063"}.glyphicon-tint:before{content:"\e064"}.glyphicon-edit:before{content:"\e065"}.glyphicon-share:before{content:"\e066"}.glyphicon-check:before{content:"\e067"}.glyphicon-move:before{content:"\e068"}.glyphicon-step-backward:before{content:"\e069"}.glyphicon-fast-backward:before{content:"\e070"}.glyphicon-backward:before{content:"\e071"}.glyphicon-play:before{content:"\e072"}.glyphicon-pause:before{content:"\e073"}.glyphicon-stop:before{content:"\e074"}.glyphicon-forward:before{content:"\e075"}.glyphicon-fast-forward:before{content:"\e076"}.glyphicon-step-forward:before{content:"\e077"}.glyphicon-eject:before{content:"\e078"}.glyphicon-chevron-left:before{content:"\e079"}.glyphicon-chevron-right:before{content:"\e080"}.glyphicon-plus-sign:before{content:"\e081"}.glyphicon-minus-sign:before{content:"\e082"}.glyphicon-remove-sign:before{content:"\e083"}.glyphicon-ok-sign:before{content:"\e084"}.glyphicon-question-sign:before{content:"\e085"}.glyphicon-info-sign:before{content:"\e086"}.glyphicon-screenshot:before{content:"\e087"}.glyphicon-remove-circle:before{content:"\e088"}.glyphicon-ok-circle:before{content:"\e089"}.glyphicon-ban-circle:before{content:"\e090"}.glyphicon-arrow-left:before{content:"\e091"}.glyphicon-arrow-right:before{content:"\e092"}.glyphicon-arrow-up:before{content:"\e093"}.glyphicon-arrow-down:before{content:"\e094"}.glyphicon-share-alt:before{content:"\e095"}.glyphicon-resize-full:before{content:"\e096"}.glyphicon-resize-small:before{content:"\e097"}.glyphicon-exclamation-sign:before{content:"\e101"}.glyphicon-gift:before{content:"\e102"}.glyphicon-leaf:before{content:"\e103"}.glyphicon-fire:before{content:"\e104"}.glyphicon-eye-open:before{content:"\e105"}.glyphicon-eye-close:before{content:"\e106"}.glyphicon-warning-sign:before{content:"\e107"}.glyphicon-plane:before{content:"\e108"}.glyphicon-calendar:before{content:"\e109"}.glyphicon-random:before{content:"\e110"}.glyphicon-comment:before{content:"\e111"}.glyphicon-magnet:before{content:"\e112"}.glyphicon-chevron-up:before{content:"\e113"}.glyphicon-chevron-down:before{content:"\e114"}.glyphicon-retweet:before{content:"\e115"}.glyphicon-shopping-cart:before{content:"\e116"}.glyphicon-folder-close:before{content:"\e117"}.glyphicon-folder-open:before{content:"\e118"}.glyphicon-resize-vertical:before{content:"\e119"}.glyphicon-resize-horizontal:before{content:"\e120"}.glyphicon-hdd:before{content:"\e121"}.glyphicon-bullhorn:before{content:"\e122"}.glyphicon-bell:before{content:"\e123"}.glyphicon-certificate:before{content:"\e124"}.glyphicon-thumbs-up:before{content:"\e125"}.glyphicon-thumbs-down:before{content:"\e126"}.glyphicon-hand-right:before{content:"\e127"}.glyphicon-hand-left:before{content:"\e128"}.glyphicon-hand-up:before{content:"\e129"}.glyphicon-hand-down:before{content:"\e130"}.glyphicon-circle-arrow-right:before{content:"\e131"}.glyphicon-circle-arrow-left:before{content:"\e132"}.glyphicon-circle-arrow-up:before{content:"\e133"}.glyphicon-circle-arrow-down:before{content:"\e134"}.glyphicon-globe:before{content:"\e135"}.glyphicon-wrench:before{content:"\e136"}.glyphicon-tasks:before{content:"\e137"}.glyphicon-filter:before{content:"\e138"}.glyphicon-briefcase:before{content:"\e139"}.glyphicon-fullscreen:before{content:"\e140"}.glyphicon-dashboard:before{content:"\e141"}.glyphicon-paperclip:before{content:"\e142"}.glyphicon-heart-empty:before{content:"\e143"}.glyphicon-link:before{content:"\e144"}.glyphicon-phone:before{content:"\e145"}.glyphicon-pushpin:before{content:"\e146"}.glyphicon-usd:before{content:"\e148"}.glyphicon-gbp:before{content:"\e149"}.glyphicon-sort:before{content:"\e150"}.glyphicon-sort-by-alphabet:before{content:"\e151"}.glyphicon-sort-by-alphabet-alt:before{content:"\e152"}.glyphicon-sort-by-order:before{content:"\e153"}.glyphicon-sort-by-order-alt:before{content:"\e154"}.glyphicon-sort-by-attributes:before{content:"\e155"}.glyphicon-sort-by-attributes-alt:before{content:"\e156"}.glyphicon-unchecked:before{content:"\e157"}.glyphicon-expand:before{content:"\e158"}.glyphicon-collapse-down:before{content:"\e159"}.glyphicon-collapse-up:before{content:"\e160"}.glyphicon-log-in:before{content:"\e161"}.glyphicon-flash:before{content:"\e162"}.glyphicon-log-out:before{content:"\e163"}.glyphicon-new-window:before{content:"\e164"}.glyphicon-record:before{content:"\e165"}.glyphicon-save:before{content:"\e166"}.glyphicon-open:before{content:"\e167"}.glyphicon-saved:before{content:"\e168"}.glyphicon-import:before{content:"\e169"}.glyphicon-export:before{content:"\e170"}.glyphicon-send:before{content:"\e171"}.glyphicon-floppy-disk:before{content:"\e172"}.glyphicon-floppy-saved:before{content:"\e173"}.glyphicon-floppy-remove:before{content:"\e174"}.glyphicon-floppy-save:before{content:"\e175"}.glyphicon-floppy-open:before{content:"\e176"}.glyphicon-credit-card:before{content:"\e177"}.glyphicon-transfer:before{content:"\e178"}.glyphicon-cutlery:before{content:"\e179"}.glyphicon-header:before{content:"\e180"}.glyphicon-compressed:before{content:"\e181"}.glyphicon-earphone:before{content:"\e182"}.glyphicon-phone-alt:before{content:"\e183"}.glyphicon-tower:before{content:"\e184"}.glyphicon-stats:before{content:"\e185"}.glyphicon-sd-video:before{content:"\e186"}.glyphicon-hd-video:before{content:"\e187"}.glyphicon-subtitles:before{content:"\e188"}.glyphicon-sound-stereo:before{content:"\e189"}.glyphicon-sound-dolby:before{content:"\e190"}.glyphicon-sound-5-1:before{content:"\e191"}.glyphicon-sound-6-1:before{content:"\e192"}.glyphicon-sound-7-1:before{content:"\e193"}.glyphicon-copyright-mark:before{content:"\e194"}.glyphicon-registration-mark:before{content:"\e195"}.glyphicon-cloud-download:before{content:"\e197"}.glyphicon-cloud-upload:before{content:"\e198"}.glyphicon-tree-conifer:before{content:"\e199"}.glyphicon-tree-deciduous:before{content:"\e200"}.glyphicon-cd:before{content:"\e201"}.glyphicon-save-file:before{content:"\e202"}.glyphicon-open-file:before{content:"\e203"}.glyphicon-level-up:before{content:"\e204"}.glyphicon-copy:before{content:"\e205"}.glyphicon-paste:before{content:"\e206"}.glyphicon-alert:before{content:"\e209"}.glyphicon-equalizer:before{content:"\e210"}.glyphicon-king:before{content:"\e211"}.glyphicon-queen:before{content:"\e212"}.glyphicon-pawn:before{content:"\e213"}.glyphicon-bishop:before{content:"\e214"}.glyphicon-knight:before{content:"\e215"}.glyphicon-baby-formula:before{content:"\e216"}.glyphicon-tent:before{content:"\26fa"}.glyphicon-blackboard:before{content:"\e218"}.glyphicon-bed:before{content:"\e219"}.glyphicon-apple:before{content:"\f8ff"}.glyphicon-erase:before{content:"\e221"}.glyphicon-hourglass:before{content:"\231b"}.glyphicon-lamp:before{content:"\e223"}.glyphicon-duplicate:before{content:"\e224"}.glyphicon-piggy-bank:before{content:"\e225"}.glyphicon-scissors:before{content:"\e226"}.glyphicon-bitcoin:before{content:"\e227"}.glyphicon-btc:before{content:"\e227"}.glyphicon-xbt:before{content:"\e227"}.glyphicon-yen:before{content:"\00a5"}.glyphicon-jpy:before{content:"\00a5"}.glyphicon-ruble:before{content:"\20bd"}.glyphicon-rub:before{content:"\20bd"}.glyphicon-scale:before{content:"\e230"}.glyphicon-ice-lolly:before{content:"\e231"}.glyphicon-ice-lolly-tasted:before{content:"\e232"}.glyphicon-education:before{content:"\e233"}.glyphicon-option-horizontal:before{content:"\e234"}.glyphicon-option-vertical:before{content:"\e235"}.glyphicon-menu-hamburger:before{content:"\e236"}.glyphicon-modal-window:before{content:"\e237"}.glyphicon-oil:before{content:"\e238"}.glyphicon-grain:before{content:"\e239"}.glyphicon-sunglasses:before{content:"\e240"}.glyphicon-text-size:before{content:"\e241"}.glyphicon-text-color:before{content:"\e242"}.glyphicon-text-background:before{content:"\e243"}.glyphicon-object-align-top:before{content:"\e244"}.glyphicon-object-align-bottom:before{content:"\e245"}.glyphicon-object-align-horizontal:before{content:"\e246"}.glyphicon-object-align-left:before{content:"\e247"}.glyphicon-object-align-vertical:before{content:"\e248"}.glyphicon-object-align-right:before{content:"\e249"}.glyphicon-triangle-right:before{content:"\e250"}.glyphicon-triangle-left:before{content:"\e251"}.glyphicon-triangle-bottom:before{content:"\e252"}.glyphicon-triangle-top:before{content:"\e253"}.glyphicon-console:before{content:"\e254"}.glyphicon-superscript:before{content:"\e255"}.glyphicon-subscript:before{content:"\e256"}.glyphicon-menu-left:before{content:"\e257"}.glyphicon-menu-right:before{content:"\e258"}.glyphicon-menu-down:before{content:"\e259"}.glyphicon-menu-up:before{content:"\e260"}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}:after,:before{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:10px;-webkit-tap-highlight-color:rgba(0,0,0,0)}body{font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:14px;line-height:1.42857143;color:#333;background-color:#fff}button,input,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit}a{color:#337ab7;text-decoration:none}a:focus,a:hover{color:#23527c;text-decoration:underline}a:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}figure{margin:0}img{vertical-align:middle}.carousel-inner>.item>a>img,.carousel-inner>.item>img,.img-responsive,.thumbnail a>img,.thumbnail>img{display:block;max-width:100%;height:auto}.img-rounded{border-radius:6px}.img-thumbnail{padding:4px;line-height:1.42857143;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out;display:inline-block;max-width:100%;height:auto}.img-circle{border-radius:50%}hr{margin-top:20px;margin-bottom:20px;border:0;border-top:1px solid #eee}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}[role=button]{cursor:pointer}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{font-family:inherit;font-weight:500;line-height:1.1;color:inherit}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-weight:400;line-height:1;color:#777}.h1,.h2,.h3,h1,h2,h3{margin-top:20px;margin-bottom:10px}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small{font-size:65%}.h4,.h5,.h6,h4,h5,h6{margin-top:10px;margin-bottom:10px}.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-size:75%}.h1,h1{font-size:36px}.h2,h2{font-size:30px}.h3,h3{font-size:24px}.h4,h4{font-size:18px}.h5,h5{font-size:14px}.h6,h6{font-size:12px}p{margin:0 0 10px}.lead{margin-bottom:20px;font-size:16px;font-weight:300;line-height:1.4}@media (min-width:768px){.lead{font-size:21px}}.small,small{font-size:85%}.mark,mark{padding:.2em;background-color:#fcf8e3}.text-left{text-align:left}.text-right{text-align:right}.text-center{text-align:center}.text-justify{text-align:justify}.text-nowrap{white-space:nowrap}.text-lowercase{text-transform:lowercase}.text-uppercase{text-transform:uppercase}.text-capitalize{text-transform:capitalize}.text-muted{color:#777}.text-primary{color:#337ab7}a.text-primary:focus,a.text-primary:hover{color:#286090}.text-success{color:#3c763d}a.text-success:focus,a.text-success:hover{color:#2b542c}.text-info{color:#31708f}a.text-info:focus,a.text-info:hover{color:#245269}.text-warning{color:#8a6d3b}a.text-warning:focus,a.text-warning:hover{color:#66512c}.text-danger{color:#a94442}a.text-danger:focus,a.text-danger:hover{color:#843534}.bg-primary{color:#fff;background-color:#337ab7}a.bg-primary:focus,a.bg-primary:hover{background-color:#286090}.bg-success{background-color:#dff0d8}a.bg-success:focus,a.bg-success:hover{background-color:#c1e2b3}.bg-info{background-color:#d9edf7}a.bg-info:focus,a.bg-info:hover{background-color:#afd9ee}.bg-warning{background-color:#fcf8e3}a.bg-warning:focus,a.bg-warning:hover{background-color:#f7ecb5}.bg-danger{background-color:#f2dede}a.bg-danger:focus,a.bg-danger:hover{background-color:#e4b9b9}.page-header{padding-bottom:9px;margin:40px 0 20px;border-bottom:1px solid #eee}ol,ul{margin-top:0;margin-bottom:10px}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}.list-unstyled{padding-left:0;list-style:none}.list-inline{padding-left:0;list-style:none;margin-left:-5px}.list-inline>li{display:inline-block;padding-right:5px;padding-left:5px}dl{margin-top:0;margin-bottom:20px}dd,dt{line-height:1.42857143}dt{font-weight:700}dd{margin-left:0}@media (min-width:768px){.dl-horizontal dt{float:left;width:160px;clear:left;text-align:right;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.dl-horizontal dd{margin-left:180px}}abbr[data-original-title],abbr[title]{cursor:help}.initialism{font-size:90%;text-transform:uppercase}blockquote{padding:10px 20px;margin:0 0 20px;font-size:17.5px;border-left:5px solid #eee}blockquote ol:last-child,blockquote p:last-child,blockquote ul:last-child{margin-bottom:0}blockquote .small,blockquote footer,blockquote small{display:block;font-size:80%;line-height:1.42857143;color:#777}blockquote .small:before,blockquote footer:before,blockquote small:before{content:"\2014 \00A0"}.blockquote-reverse,blockquote.pull-right{padding-right:15px;padding-left:0;text-align:right;border-right:5px solid #eee;border-left:0}.blockquote-reverse .small:before,.blockquote-reverse footer:before,.blockquote-reverse small:before,blockquote.pull-right .small:before,blockquote.pull-right footer:before,blockquote.pull-right small:before{content:""}.blockquote-reverse .small:after,.blockquote-reverse footer:after,.blockquote-reverse small:after,blockquote.pull-right .small:after,blockquote.pull-right footer:after,blockquote.pull-right small:after{content:"\00A0 \2014"}address{margin-bottom:20px;font-style:normal;line-height:1.42857143}code,kbd,pre,samp{font-family:Menlo,Monaco,Consolas,"Courier New",monospace}code{padding:2px 4px;font-size:90%;color:#c7254e;background-color:#f9f2f4;border-radius:4px}kbd{padding:2px 4px;font-size:90%;color:#fff;background-color:#333;border-radius:3px;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,.25);box-shadow:inset 0 -1px 0 rgba(0,0,0,.25)}kbd kbd{padding:0;font-size:100%;font-weight:700;-webkit-box-shadow:none;box-shadow:none}pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:1.42857143;color:#333;word-break:break-all;word-wrap:break-word;background-color:#f5f5f5;border:1px solid #ccc;border-radius:4px}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border-radius:0}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}@media (min-width:768px){.container{width:750px}}@media (min-width:992px){.container{width:970px}}@media (min-width:1200px){.container{width:1170px}}.container-fluid{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}.row{margin-right:-15px;margin-left:-15px}.row-no-gutters{margin-right:0;margin-left:0}.row-no-gutters [class*=col-]{padding-right:0;padding-left:0}.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-xs-1,.col-xs-10,.col-xs-11,.col-xs-12,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9{position:relative;min-height:1px;padding-right:15px;padding-left:15px}.col-xs-1,.col-xs-10,.col-xs-11,.col-xs-12,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9{float:left}.col-xs-12{width:100%}.col-xs-11{width:91.66666667%}.col-xs-10{width:83.33333333%}.col-xs-9{width:75%}.col-xs-8{width:66.66666667%}.col-xs-7{width:58.33333333%}.col-xs-6{width:50%}.col-xs-5{width:41.66666667%}.col-xs-4{width:33.33333333%}.col-xs-3{width:25%}.col-xs-2{width:16.66666667%}.col-xs-1{width:8.33333333%}.col-xs-pull-12{right:100%}.col-xs-pull-11{right:91.66666667%}.col-xs-pull-10{right:83.33333333%}.col-xs-pull-9{right:75%}.col-xs-pull-8{right:66.66666667%}.col-xs-pull-7{right:58.33333333%}.col-xs-pull-6{right:50%}.col-xs-pull-5{right:41.66666667%}.col-xs-pull-4{right:33.33333333%}.col-xs-pull-3{right:25%}.col-xs-pull-2{right:16.66666667%}.col-xs-pull-1{right:8.33333333%}.col-xs-pull-0{right:auto}.col-xs-push-12{left:100%}.col-xs-push-11{left:91.66666667%}.col-xs-push-10{left:83.33333333%}.col-xs-push-9{left:75%}.col-xs-push-8{left:66.66666667%}.col-xs-push-7{left:58.33333333%}.col-xs-push-6{left:50%}.col-xs-push-5{left:41.66666667%}.col-xs-push-4{left:33.33333333%}.col-xs-push-3{left:25%}.col-xs-push-2{left:16.66666667%}.col-xs-push-1{left:8.33333333%}.col-xs-push-0{left:auto}.col-xs-offset-12{margin-left:100%}.col-xs-offset-11{margin-left:91.66666667%}.col-xs-offset-10{margin-left:83.33333333%}.col-xs-offset-9{margin-left:75%}.col-xs-offset-8{margin-left:66.66666667%}.col-xs-offset-7{margin-left:58.33333333%}.col-xs-offset-6{margin-left:50%}.col-xs-offset-5{margin-left:41.66666667%}.col-xs-offset-4{margin-left:33.33333333%}.col-xs-offset-3{margin-left:25%}.col-xs-offset-2{margin-left:16.66666667%}.col-xs-offset-1{margin-left:8.33333333%}.col-xs-offset-0{margin-left:0}@media (min-width:768px){.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9{float:left}.col-sm-12{width:100%}.col-sm-11{width:91.66666667%}.col-sm-10{width:83.33333333%}.col-sm-9{width:75%}.col-sm-8{width:66.66666667%}.col-sm-7{width:58.33333333%}.col-sm-6{width:50%}.col-sm-5{width:41.66666667%}.col-sm-4{width:33.33333333%}.col-sm-3{width:25%}.col-sm-2{width:16.66666667%}.col-sm-1{width:8.33333333%}.col-sm-pull-12{right:100%}.col-sm-pull-11{right:91.66666667%}.col-sm-pull-10{right:83.33333333%}.col-sm-pull-9{right:75%}.col-sm-pull-8{right:66.66666667%}.col-sm-pull-7{right:58.33333333%}.col-sm-pull-6{right:50%}.col-sm-pull-5{right:41.66666667%}.col-sm-pull-4{right:33.33333333%}.col-sm-pull-3{right:25%}.col-sm-pull-2{right:16.66666667%}.col-sm-pull-1{right:8.33333333%}.col-sm-pull-0{right:auto}.col-sm-push-12{left:100%}.col-sm-push-11{left:91.66666667%}.col-sm-push-10{left:83.33333333%}.col-sm-push-9{left:75%}.col-sm-push-8{left:66.66666667%}.col-sm-push-7{left:58.33333333%}.col-sm-push-6{left:50%}.col-sm-push-5{left:41.66666667%}.col-sm-push-4{left:33.33333333%}.col-sm-push-3{left:25%}.col-sm-push-2{left:16.66666667%}.col-sm-push-1{left:8.33333333%}.col-sm-push-0{left:auto}.col-sm-offset-12{margin-left:100%}.col-sm-offset-11{margin-left:91.66666667%}.col-sm-offset-10{margin-left:83.33333333%}.col-sm-offset-9{margin-left:75%}.col-sm-offset-8{margin-left:66.66666667%}.col-sm-offset-7{margin-left:58.33333333%}.col-sm-offset-6{margin-left:50%}.col-sm-offset-5{margin-left:41.66666667%}.col-sm-offset-4{margin-left:33.33333333%}.col-sm-offset-3{margin-left:25%}.col-sm-offset-2{margin-left:16.66666667%}.col-sm-offset-1{margin-left:8.33333333%}.col-sm-offset-0{margin-left:0}}@media (min-width:992px){.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9{float:left}.col-md-12{width:100%}.col-md-11{width:91.66666667%}.col-md-10{width:83.33333333%}.col-md-9{width:75%}.col-md-8{width:66.66666667%}.col-md-7{width:58.33333333%}.col-md-6{width:50%}.col-md-5{width:41.66666667%}.col-md-4{width:33.33333333%}.col-md-3{width:25%}.col-md-2{width:16.66666667%}.col-md-1{width:8.33333333%}.col-md-pull-12{right:100%}.col-md-pull-11{right:91.66666667%}.col-md-pull-10{right:83.33333333%}.col-md-pull-9{right:75%}.col-md-pull-8{right:66.66666667%}.col-md-pull-7{right:58.33333333%}.col-md-pull-6{right:50%}.col-md-pull-5{right:41.66666667%}.col-md-pull-4{right:33.33333333%}.col-md-pull-3{right:25%}.col-md-pull-2{right:16.66666667%}.col-md-pull-1{right:8.33333333%}.col-md-pull-0{right:auto}.col-md-push-12{left:100%}.col-md-push-11{left:91.66666667%}.col-md-push-10{left:83.33333333%}.col-md-push-9{left:75%}.col-md-push-8{left:66.66666667%}.col-md-push-7{left:58.33333333%}.col-md-push-6{left:50%}.col-md-push-5{left:41.66666667%}.col-md-push-4{left:33.33333333%}.col-md-push-3{left:25%}.col-md-push-2{left:16.66666667%}.col-md-push-1{left:8.33333333%}.col-md-push-0{left:auto}.col-md-offset-12{margin-left:100%}.col-md-offset-11{margin-left:91.66666667%}.col-md-offset-10{margin-left:83.33333333%}.col-md-offset-9{margin-left:75%}.col-md-offset-8{margin-left:66.66666667%}.col-md-offset-7{margin-left:58.33333333%}.col-md-offset-6{margin-left:50%}.col-md-offset-5{margin-left:41.66666667%}.col-md-offset-4{margin-left:33.33333333%}.col-md-offset-3{margin-left:25%}.col-md-offset-2{margin-left:16.66666667%}.col-md-offset-1{margin-left:8.33333333%}.col-md-offset-0{margin-left:0}}@media (min-width:1200px){.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9{float:left}.col-lg-12{width:100%}.col-lg-11{width:91.66666667%}.col-lg-10{width:83.33333333%}.col-lg-9{width:75%}.col-lg-8{width:66.66666667%}.col-lg-7{width:58.33333333%}.col-lg-6{width:50%}.col-lg-5{width:41.66666667%}.col-lg-4{width:33.33333333%}.col-lg-3{width:25%}.col-lg-2{width:16.66666667%}.col-lg-1{width:8.33333333%}.col-lg-pull-12{right:100%}.col-lg-pull-11{right:91.66666667%}.col-lg-pull-10{right:83.33333333%}.col-lg-pull-9{right:75%}.col-lg-pull-8{right:66.66666667%}.col-lg-pull-7{right:58.33333333%}.col-lg-pull-6{right:50%}.col-lg-pull-5{right:41.66666667%}.col-lg-pull-4{right:33.33333333%}.col-lg-pull-3{right:25%}.col-lg-pull-2{right:16.66666667%}.col-lg-pull-1{right:8.33333333%}.col-lg-pull-0{right:auto}.col-lg-push-12{left:100%}.col-lg-push-11{left:91.66666667%}.col-lg-push-10{left:83.33333333%}.col-lg-push-9{left:75%}.col-lg-push-8{left:66.66666667%}.col-lg-push-7{left:58.33333333%}.col-lg-push-6{left:50%}.col-lg-push-5{left:41.66666667%}.col-lg-push-4{left:33.33333333%}.col-lg-push-3{left:25%}.col-lg-push-2{left:16.66666667%}.col-lg-push-1{left:8.33333333%}.col-lg-push-0{left:auto}.col-lg-offset-12{margin-left:100%}.col-lg-offset-11{margin-left:91.66666667%}.col-lg-offset-10{margin-left:83.33333333%}.col-lg-offset-9{margin-left:75%}.col-lg-offset-8{margin-left:66.66666667%}.col-lg-offset-7{margin-left:58.33333333%}.col-lg-offset-6{margin-left:50%}.col-lg-offset-5{margin-left:41.66666667%}.col-lg-offset-4{margin-left:33.33333333%}.col-lg-offset-3{margin-left:25%}.col-lg-offset-2{margin-left:16.66666667%}.col-lg-offset-1{margin-left:8.33333333%}.col-lg-offset-0{margin-left:0}}table{background-color:transparent}table col[class*=col-]{position:static;display:table-column;float:none}table td[class*=col-],table th[class*=col-]{position:static;display:table-cell;float:none}caption{padding-top:8px;padding-bottom:8px;color:#777;text-align:left}th{text-align:left}.table{width:100%;max-width:100%;margin-bottom:20px}.table>tbody>tr>td,.table>tbody>tr>th,.table>tfoot>tr>td,.table>tfoot>tr>th,.table>thead>tr>td,.table>thead>tr>th{padding:8px;line-height:1.42857143;vertical-align:top;border-top:1px solid #ddd}.table>thead>tr>th{vertical-align:bottom;border-bottom:2px solid #ddd}.table>caption+thead>tr:first-child>td,.table>caption+thead>tr:first-child>th,.table>colgroup+thead>tr:first-child>td,.table>colgroup+thead>tr:first-child>th,.table>thead:first-child>tr:first-child>td,.table>thead:first-child>tr:first-child>th{border-top:0}.table>tbody+tbody{border-top:2px solid #ddd}.table .table{background-color:#fff}.table-condensed>tbody>tr>td,.table-condensed>tbody>tr>th,.table-condensed>tfoot>tr>td,.table-condensed>tfoot>tr>th,.table-condensed>thead>tr>td,.table-condensed>thead>tr>th{padding:5px}.table-bordered{border:1px solid #ddd}.table-bordered>tbody>tr>td,.table-bordered>tbody>tr>th,.table-bordered>tfoot>tr>td,.table-bordered>tfoot>tr>th,.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border:1px solid #ddd}.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border-bottom-width:2px}.table-striped>tbody>tr:nth-of-type(odd){background-color:#f9f9f9}.table-hover>tbody>tr:hover{background-color:#f5f5f5}.table>tbody>tr.active>td,.table>tbody>tr.active>th,.table>tbody>tr>td.active,.table>tbody>tr>th.active,.table>tfoot>tr.active>td,.table>tfoot>tr.active>th,.table>tfoot>tr>td.active,.table>tfoot>tr>th.active,.table>thead>tr.active>td,.table>thead>tr.active>th,.table>thead>tr>td.active,.table>thead>tr>th.active{background-color:#f5f5f5}.table-hover>tbody>tr.active:hover>td,.table-hover>tbody>tr.active:hover>th,.table-hover>tbody>tr:hover>.active,.table-hover>tbody>tr>td.active:hover,.table-hover>tbody>tr>th.active:hover{background-color:#e8e8e8}.table>tbody>tr.success>td,.table>tbody>tr.success>th,.table>tbody>tr>td.success,.table>tbody>tr>th.success,.table>tfoot>tr.success>td,.table>tfoot>tr.success>th,.table>tfoot>tr>td.success,.table>tfoot>tr>th.success,.table>thead>tr.success>td,.table>thead>tr.success>th,.table>thead>tr>td.success,.table>thead>tr>th.success{background-color:#dff0d8}.table-hover>tbody>tr.success:hover>td,.table-hover>tbody>tr.success:hover>th,.table-hover>tbody>tr:hover>.success,.table-hover>tbody>tr>td.success:hover,.table-hover>tbody>tr>th.success:hover{background-color:#d0e9c6}.table>tbody>tr.info>td,.table>tbody>tr.info>th,.table>tbody>tr>td.info,.table>tbody>tr>th.info,.table>tfoot>tr.info>td,.table>tfoot>tr.info>th,.table>tfoot>tr>td.info,.table>tfoot>tr>th.info,.table>thead>tr.info>td,.table>thead>tr.info>th,.table>thead>tr>td.info,.table>thead>tr>th.info{background-color:#d9edf7}.table-hover>tbody>tr.info:hover>td,.table-hover>tbody>tr.info:hover>th,.table-hover>tbody>tr:hover>.info,.table-hover>tbody>tr>td.info:hover,.table-hover>tbody>tr>th.info:hover{background-color:#c4e3f3}.table>tbody>tr.warning>td,.table>tbody>tr.warning>th,.table>tbody>tr>td.warning,.table>tbody>tr>th.warning,.table>tfoot>tr.warning>td,.table>tfoot>tr.warning>th,.table>tfoot>tr>td.warning,.table>tfoot>tr>th.warning,.table>thead>tr.warning>td,.table>thead>tr.warning>th,.table>thead>tr>td.warning,.table>thead>tr>th.warning{background-color:#fcf8e3}.table-hover>tbody>tr.warning:hover>td,.table-hover>tbody>tr.warning:hover>th,.table-hover>tbody>tr:hover>.warning,.table-hover>tbody>tr>td.warning:hover,.table-hover>tbody>tr>th.warning:hover{background-color:#faf2cc}.table>tbody>tr.danger>td,.table>tbody>tr.danger>th,.table>tbody>tr>td.danger,.table>tbody>tr>th.danger,.table>tfoot>tr.danger>td,.table>tfoot>tr.danger>th,.table>tfoot>tr>td.danger,.table>tfoot>tr>th.danger,.table>thead>tr.danger>td,.table>thead>tr.danger>th,.table>thead>tr>td.danger,.table>thead>tr>th.danger{background-color:#f2dede}.table-hover>tbody>tr.danger:hover>td,.table-hover>tbody>tr.danger:hover>th,.table-hover>tbody>tr:hover>.danger,.table-hover>tbody>tr>td.danger:hover,.table-hover>tbody>tr>th.danger:hover{background-color:#ebcccc}.table-responsive{min-height:.01%;overflow-x:auto}@media screen and (max-width:767px){.table-responsive{width:100%;margin-bottom:15px;overflow-y:hidden;-ms-overflow-style:-ms-autohiding-scrollbar;border:1px solid #ddd}.table-responsive>.table{margin-bottom:0}.table-responsive>.table>tbody>tr>td,.table-responsive>.table>tbody>tr>th,.table-responsive>.table>tfoot>tr>td,.table-responsive>.table>tfoot>tr>th,.table-responsive>.table>thead>tr>td,.table-responsive>.table>thead>tr>th{white-space:nowrap}.table-responsive>.table-bordered{border:0}.table-responsive>.table-bordered>tbody>tr>td:first-child,.table-responsive>.table-bordered>tbody>tr>th:first-child,.table-responsive>.table-bordered>tfoot>tr>td:first-child,.table-responsive>.table-bordered>tfoot>tr>th:first-child,.table-responsive>.table-bordered>thead>tr>td:first-child,.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.table-responsive>.table-bordered>tbody>tr>td:last-child,.table-responsive>.table-bordered>tbody>tr>th:last-child,.table-responsive>.table-bordered>tfoot>tr>td:last-child,.table-responsive>.table-bordered>tfoot>tr>th:last-child,.table-responsive>.table-bordered>thead>tr>td:last-child,.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.table-responsive>.table-bordered>tbody>tr:last-child>td,.table-responsive>.table-bordered>tbody>tr:last-child>th,.table-responsive>.table-bordered>tfoot>tr:last-child>td,.table-responsive>.table-bordered>tfoot>tr:last-child>th{border-bottom:0}}fieldset{min-width:0;padding:0;margin:0;border:0}legend{display:block;width:100%;padding:0;margin-bottom:20px;font-size:21px;line-height:inherit;color:#333;border:0;border-bottom:1px solid #e5e5e5}label{display:inline-block;max-width:100%;margin-bottom:5px;font-weight:700}input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;-webkit-appearance:none;-moz-appearance:none;appearance:none}input[type=checkbox],input[type=radio]{margin:4px 0 0;margin-top:1px\9;line-height:normal}fieldset[disabled] input[type=checkbox],fieldset[disabled] input[type=radio],input[type=checkbox].disabled,input[type=checkbox][disabled],input[type=radio].disabled,input[type=radio][disabled]{cursor:not-allowed}input[type=file]{display:block}input[type=range]{display:block;width:100%}select[multiple],select[size]{height:auto}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}output{display:block;padding-top:7px;font-size:14px;line-height:1.42857143;color:#555}.form-control{display:block;width:100%;height:34px;padding:6px 12px;font-size:14px;line-height:1.42857143;color:#555;background-color:#fff;background-image:none;border:1px solid #ccc;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);-webkit-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;-o-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;-webkit-transition:border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s,-webkit-box-shadow ease-in-out .15s}.form-control:focus{border-color:#66afe9;outline:0;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6)}.form-control::-moz-placeholder{color:#999;opacity:1}.form-control:-ms-input-placeholder{color:#999}.form-control::-webkit-input-placeholder{color:#999}.form-control::-ms-expand{background-color:transparent;border:0}.form-control[disabled],.form-control[readonly],fieldset[disabled] .form-control{background-color:#eee;opacity:1}.form-control[disabled],fieldset[disabled] .form-control{cursor:not-allowed}textarea.form-control{height:auto}@media screen and (-webkit-min-device-pixel-ratio:0){input[type=date].form-control,input[type=datetime-local].form-control,input[type=month].form-control,input[type=time].form-control{line-height:34px}.input-group-sm input[type=date],.input-group-sm input[type=datetime-local],.input-group-sm input[type=month],.input-group-sm input[type=time],input[type=date].input-sm,input[type=datetime-local].input-sm,input[type=month].input-sm,input[type=time].input-sm{line-height:30px}.input-group-lg input[type=date],.input-group-lg input[type=datetime-local],.input-group-lg input[type=month],.input-group-lg input[type=time],input[type=date].input-lg,input[type=datetime-local].input-lg,input[type=month].input-lg,input[type=time].input-lg{line-height:46px}}.form-group{margin-bottom:15px}.checkbox,.radio{position:relative;display:block;margin-top:10px;margin-bottom:10px}.checkbox.disabled label,.radio.disabled label,fieldset[disabled] .checkbox label,fieldset[disabled] .radio label{cursor:not-allowed}.checkbox label,.radio label{min-height:20px;padding-left:20px;margin-bottom:0;font-weight:400;cursor:pointer}.checkbox input[type=checkbox],.checkbox-inline input[type=checkbox],.radio input[type=radio],.radio-inline input[type=radio]{position:absolute;margin-top:4px\9;margin-left:-20px}.checkbox+.checkbox,.radio+.radio{margin-top:-5px}.checkbox-inline,.radio-inline{position:relative;display:inline-block;padding-left:20px;margin-bottom:0;font-weight:400;vertical-align:middle;cursor:pointer}.checkbox-inline.disabled,.radio-inline.disabled,fieldset[disabled] .checkbox-inline,fieldset[disabled] .radio-inline{cursor:not-allowed}.checkbox-inline+.checkbox-inline,.radio-inline+.radio-inline{margin-top:0;margin-left:10px}.form-control-static{min-height:34px;padding-top:7px;padding-bottom:7px;margin-bottom:0}.form-control-static.input-lg,.form-control-static.input-sm{padding-right:0;padding-left:0}.input-sm{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}select.input-sm{height:30px;line-height:30px}select[multiple].input-sm,textarea.input-sm{height:auto}.form-group-sm .form-control{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.form-group-sm select.form-control{height:30px;line-height:30px}.form-group-sm select[multiple].form-control,.form-group-sm textarea.form-control{height:auto}.form-group-sm .form-control-static{height:30px;min-height:32px;padding:6px 10px;font-size:12px;line-height:1.5}.input-lg{height:46px;padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}select.input-lg{height:46px;line-height:46px}select[multiple].input-lg,textarea.input-lg{height:auto}.form-group-lg .form-control{height:46px;padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}.form-group-lg select.form-control{height:46px;line-height:46px}.form-group-lg select[multiple].form-control,.form-group-lg textarea.form-control{height:auto}.form-group-lg .form-control-static{height:46px;min-height:38px;padding:11px 16px;font-size:18px;line-height:1.3333333}.has-feedback{position:relative}.has-feedback .form-control{padding-right:42.5px}.form-control-feedback{position:absolute;top:0;right:0;z-index:2;display:block;width:34px;height:34px;line-height:34px;text-align:center;pointer-events:none}.form-group-lg .form-control+.form-control-feedback,.input-group-lg+.form-control-feedback,.input-lg+.form-control-feedback{width:46px;height:46px;line-height:46px}.form-group-sm .form-control+.form-control-feedback,.input-group-sm+.form-control-feedback,.input-sm+.form-control-feedback{width:30px;height:30px;line-height:30px}.has-success .checkbox,.has-success .checkbox-inline,.has-success .control-label,.has-success .help-block,.has-success .radio,.has-success .radio-inline,.has-success.checkbox label,.has-success.checkbox-inline label,.has-success.radio label,.has-success.radio-inline label{color:#3c763d}.has-success .form-control{border-color:#3c763d;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-success .form-control:focus{border-color:#2b542c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168}.has-success .input-group-addon{color:#3c763d;background-color:#dff0d8;border-color:#3c763d}.has-success .form-control-feedback{color:#3c763d}.has-warning .checkbox,.has-warning .checkbox-inline,.has-warning .control-label,.has-warning .help-block,.has-warning .radio,.has-warning .radio-inline,.has-warning.checkbox label,.has-warning.checkbox-inline label,.has-warning.radio label,.has-warning.radio-inline label{color:#8a6d3b}.has-warning .form-control{border-color:#8a6d3b;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-warning .form-control:focus{border-color:#66512c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b}.has-warning .input-group-addon{color:#8a6d3b;background-color:#fcf8e3;border-color:#8a6d3b}.has-warning .form-control-feedback{color:#8a6d3b}.has-error .checkbox,.has-error .checkbox-inline,.has-error .control-label,.has-error .help-block,.has-error .radio,.has-error .radio-inline,.has-error.checkbox label,.has-error.checkbox-inline label,.has-error.radio label,.has-error.radio-inline label{color:#a94442}.has-error .form-control{border-color:#a94442;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-error .form-control:focus{border-color:#843534;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483}.has-error .input-group-addon{color:#a94442;background-color:#f2dede;border-color:#a94442}.has-error .form-control-feedback{color:#a94442}.has-feedback label~.form-control-feedback{top:25px}.has-feedback label.sr-only~.form-control-feedback{top:0}.help-block{display:block;margin-top:5px;margin-bottom:10px;color:#737373}@media (min-width:768px){.form-inline .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .form-control-static{display:inline-block}.form-inline .input-group{display:inline-table;vertical-align:middle}.form-inline .input-group .form-control,.form-inline .input-group .input-group-addon,.form-inline .input-group .input-group-btn{width:auto}.form-inline .input-group>.form-control{width:100%}.form-inline .control-label{margin-bottom:0;vertical-align:middle}.form-inline .checkbox,.form-inline .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.form-inline .checkbox label,.form-inline .radio label{padding-left:0}.form-inline .checkbox input[type=checkbox],.form-inline .radio input[type=radio]{position:relative;margin-left:0}.form-inline .has-feedback .form-control-feedback{top:0}}.form-horizontal .checkbox,.form-horizontal .checkbox-inline,.form-horizontal .radio,.form-horizontal .radio-inline{padding-top:7px;margin-top:0;margin-bottom:0}.form-horizontal .checkbox,.form-horizontal .radio{min-height:27px}.form-horizontal .form-group{margin-right:-15px;margin-left:-15px}@media (min-width:768px){.form-horizontal .control-label{padding-top:7px;margin-bottom:0;text-align:right}}.form-horizontal .has-feedback .form-control-feedback{right:15px}@media (min-width:768px){.form-horizontal .form-group-lg .control-label{padding-top:11px;font-size:18px}}@media (min-width:768px){.form-horizontal .form-group-sm .control-label{padding-top:6px;font-size:12px}}.btn{display:inline-block;margin-bottom:0;font-weight:400;text-align:center;white-space:nowrap;vertical-align:middle;-ms-touch-action:manipulation;touch-action:manipulation;cursor:pointer;background-image:none;border:1px solid transparent;padding:6px 12px;font-size:14px;line-height:1.42857143;border-radius:4px;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.btn.active.focus,.btn.active:focus,.btn.focus,.btn:active.focus,.btn:active:focus,.btn:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.btn.focus,.btn:focus,.btn:hover{color:#333;text-decoration:none}.btn.active,.btn:active{background-image:none;outline:0;-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn.disabled,.btn[disabled],fieldset[disabled] .btn{cursor:not-allowed;filter:alpha(opacity=65);opacity:.65;-webkit-box-shadow:none;box-shadow:none}a.btn.disabled,fieldset[disabled] a.btn{pointer-events:none}.btn-default{color:#333;background-color:#fff;border-color:#ccc}.btn-default.focus,.btn-default:focus{color:#333;background-color:#e6e6e6;border-color:#8c8c8c}.btn-default:hover{color:#333;background-color:#e6e6e6;border-color:#adadad}.btn-default.active,.btn-default:active,.open>.dropdown-toggle.btn-default{color:#333;background-color:#e6e6e6;background-image:none;border-color:#adadad}.btn-default.active.focus,.btn-default.active:focus,.btn-default.active:hover,.btn-default:active.focus,.btn-default:active:focus,.btn-default:active:hover,.open>.dropdown-toggle.btn-default.focus,.open>.dropdown-toggle.btn-default:focus,.open>.dropdown-toggle.btn-default:hover{color:#333;background-color:#d4d4d4;border-color:#8c8c8c}.btn-default.disabled.focus,.btn-default.disabled:focus,.btn-default.disabled:hover,.btn-default[disabled].focus,.btn-default[disabled]:focus,.btn-default[disabled]:hover,fieldset[disabled] .btn-default.focus,fieldset[disabled] .btn-default:focus,fieldset[disabled] .btn-default:hover{background-color:#fff;border-color:#ccc}.btn-default .badge{color:#fff;background-color:#333}.btn-primary{color:#fff;background-color:#337ab7;border-color:#2e6da4}.btn-primary.focus,.btn-primary:focus{color:#fff;background-color:#286090;border-color:#122b40}.btn-primary:hover{color:#fff;background-color:#286090;border-color:#204d74}.btn-primary.active,.btn-primary:active,.open>.dropdown-toggle.btn-primary{color:#fff;background-color:#286090;background-image:none;border-color:#204d74}.btn-primary.active.focus,.btn-primary.active:focus,.btn-primary.active:hover,.btn-primary:active.focus,.btn-primary:active:focus,.btn-primary:active:hover,.open>.dropdown-toggle.btn-primary.focus,.open>.dropdown-toggle.btn-primary:focus,.open>.dropdown-toggle.btn-primary:hover{color:#fff;background-color:#204d74;border-color:#122b40}.btn-primary.disabled.focus,.btn-primary.disabled:focus,.btn-primary.disabled:hover,.btn-primary[disabled].focus,.btn-primary[disabled]:focus,.btn-primary[disabled]:hover,fieldset[disabled] .btn-primary.focus,fieldset[disabled] .btn-primary:focus,fieldset[disabled] .btn-primary:hover{background-color:#337ab7;border-color:#2e6da4}.btn-primary .badge{color:#337ab7;background-color:#fff}.btn-success{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.btn-success.focus,.btn-success:focus{color:#fff;background-color:#449d44;border-color:#255625}.btn-success:hover{color:#fff;background-color:#449d44;border-color:#398439}.btn-success.active,.btn-success:active,.open>.dropdown-toggle.btn-success{color:#fff;background-color:#449d44;background-image:none;border-color:#398439}.btn-success.active.focus,.btn-success.active:focus,.btn-success.active:hover,.btn-success:active.focus,.btn-success:active:focus,.btn-success:active:hover,.open>.dropdown-toggle.btn-success.focus,.open>.dropdown-toggle.btn-success:focus,.open>.dropdown-toggle.btn-success:hover{color:#fff;background-color:#398439;border-color:#255625}.btn-success.disabled.focus,.btn-success.disabled:focus,.btn-success.disabled:hover,.btn-success[disabled].focus,.btn-success[disabled]:focus,.btn-success[disabled]:hover,fieldset[disabled] .btn-success.focus,fieldset[disabled] .btn-success:focus,fieldset[disabled] .btn-success:hover{background-color:#5cb85c;border-color:#4cae4c}.btn-success .badge{color:#5cb85c;background-color:#fff}.btn-info{color:#fff;background-color:#5bc0de;border-color:#46b8da}.btn-info.focus,.btn-info:focus{color:#fff;background-color:#31b0d5;border-color:#1b6d85}.btn-info:hover{color:#fff;background-color:#31b0d5;border-color:#269abc}.btn-info.active,.btn-info:active,.open>.dropdown-toggle.btn-info{color:#fff;background-color:#31b0d5;background-image:none;border-color:#269abc}.btn-info.active.focus,.btn-info.active:focus,.btn-info.active:hover,.btn-info:active.focus,.btn-info:active:focus,.btn-info:active:hover,.open>.dropdown-toggle.btn-info.focus,.open>.dropdown-toggle.btn-info:focus,.open>.dropdown-toggle.btn-info:hover{color:#fff;background-color:#269abc;border-color:#1b6d85}.btn-info.disabled.focus,.btn-info.disabled:focus,.btn-info.disabled:hover,.btn-info[disabled].focus,.btn-info[disabled]:focus,.btn-info[disabled]:hover,fieldset[disabled] .btn-info.focus,fieldset[disabled] .btn-info:focus,fieldset[disabled] .btn-info:hover{background-color:#5bc0de;border-color:#46b8da}.btn-info .badge{color:#5bc0de;background-color:#fff}.btn-warning{color:#fff;background-color:#f0ad4e;border-color:#eea236}.btn-warning.focus,.btn-warning:focus{color:#fff;background-color:#ec971f;border-color:#985f0d}.btn-warning:hover{color:#fff;background-color:#ec971f;border-color:#d58512}.btn-warning.active,.btn-warning:active,.open>.dropdown-toggle.btn-warning{color:#fff;background-color:#ec971f;background-image:none;border-color:#d58512}.btn-warning.active.focus,.btn-warning.active:focus,.btn-warning.active:hover,.btn-warning:active.focus,.btn-warning:active:focus,.btn-warning:active:hover,.open>.dropdown-toggle.btn-warning.focus,.open>.dropdown-toggle.btn-warning:focus,.open>.dropdown-toggle.btn-warning:hover{color:#fff;background-color:#d58512;border-color:#985f0d}.btn-warning.disabled.focus,.btn-warning.disabled:focus,.btn-warning.disabled:hover,.btn-warning[disabled].focus,.btn-warning[disabled]:focus,.btn-warning[disabled]:hover,fieldset[disabled] .btn-warning.focus,fieldset[disabled] .btn-warning:focus,fieldset[disabled] .btn-warning:hover{background-color:#f0ad4e;border-color:#eea236}.btn-warning .badge{color:#f0ad4e;background-color:#fff}.btn-danger{color:#fff;background-color:#d9534f;border-color:#d43f3a}.btn-danger.focus,.btn-danger:focus{color:#fff;background-color:#c9302c;border-color:#761c19}.btn-danger:hover{color:#fff;background-color:#c9302c;border-color:#ac2925}.btn-danger.active,.btn-danger:active,.open>.dropdown-toggle.btn-danger{color:#fff;background-color:#c9302c;background-image:none;border-color:#ac2925}.btn-danger.active.focus,.btn-danger.active:focus,.btn-danger.active:hover,.btn-danger:active.focus,.btn-danger:active:focus,.btn-danger:active:hover,.open>.dropdown-toggle.btn-danger.focus,.open>.dropdown-toggle.btn-danger:focus,.open>.dropdown-toggle.btn-danger:hover{color:#fff;background-color:#ac2925;border-color:#761c19}.btn-danger.disabled.focus,.btn-danger.disabled:focus,.btn-danger.disabled:hover,.btn-danger[disabled].focus,.btn-danger[disabled]:focus,.btn-danger[disabled]:hover,fieldset[disabled] .btn-danger.focus,fieldset[disabled] .btn-danger:focus,fieldset[disabled] .btn-danger:hover{background-color:#d9534f;border-color:#d43f3a}.btn-danger .badge{color:#d9534f;background-color:#fff}.btn-link{font-weight:400;color:#337ab7;border-radius:0}.btn-link,.btn-link.active,.btn-link:active,.btn-link[disabled],fieldset[disabled] .btn-link{background-color:transparent;-webkit-box-shadow:none;box-shadow:none}.btn-link,.btn-link:active,.btn-link:focus,.btn-link:hover{border-color:transparent}.btn-link:focus,.btn-link:hover{color:#23527c;text-decoration:underline;background-color:transparent}.btn-link[disabled]:focus,.btn-link[disabled]:hover,fieldset[disabled] .btn-link:focus,fieldset[disabled] .btn-link:hover{color:#777;text-decoration:none}.btn-group-lg>.btn,.btn-lg{padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}.btn-group-sm>.btn,.btn-sm{padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.btn-group-xs>.btn,.btn-xs{padding:1px 5px;font-size:12px;line-height:1.5;border-radius:3px}.btn-block{display:block;width:100%}.btn-block+.btn-block{margin-top:5px}input[type=button].btn-block,input[type=reset].btn-block,input[type=submit].btn-block{width:100%}.fade{opacity:0;-webkit-transition:opacity .15s linear;-o-transition:opacity .15s linear;transition:opacity .15s linear}.fade.in{opacity:1}.collapse{display:none}.collapse.in{display:block}tr.collapse.in{display:table-row}tbody.collapse.in{display:table-row-group}.collapsing{position:relative;height:0;overflow:hidden;-webkit-transition-property:height,visibility;-o-transition-property:height,visibility;transition-property:height,visibility;-webkit-transition-duration:.35s;-o-transition-duration:.35s;transition-duration:.35s;-webkit-transition-timing-function:ease;-o-transition-timing-function:ease;transition-timing-function:ease}.caret{display:inline-block;width:0;height:0;margin-left:2px;vertical-align:middle;border-top:4px dashed;border-top:4px solid\9;border-right:4px solid transparent;border-left:4px solid transparent}.dropdown,.dropup{position:relative}.dropdown-toggle:focus{outline:0}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;font-size:14px;text-align:left;list-style:none;background-color:#fff;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.15);border-radius:4px;-webkit-box-shadow:0 6px 12px rgba(0,0,0,.175);box-shadow:0 6px 12px rgba(0,0,0,.175)}.dropdown-menu.pull-right{right:0;left:auto}.dropdown-menu .divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.dropdown-menu>li>a{display:block;padding:3px 20px;clear:both;font-weight:400;line-height:1.42857143;color:#333;white-space:nowrap}.dropdown-menu>li>a:focus,.dropdown-menu>li>a:hover{color:#262626;text-decoration:none;background-color:#f5f5f5}.dropdown-menu>.active>a,.dropdown-menu>.active>a:focus,.dropdown-menu>.active>a:hover{color:#fff;text-decoration:none;background-color:#337ab7;outline:0}.dropdown-menu>.disabled>a,.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{color:#777}.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{text-decoration:none;cursor:not-allowed;background-color:transparent;background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.open>.dropdown-menu{display:block}.open>a{outline:0}.dropdown-menu-right{right:0;left:auto}.dropdown-menu-left{right:auto;left:0}.dropdown-header{display:block;padding:3px 20px;font-size:12px;line-height:1.42857143;color:#777;white-space:nowrap}.dropdown-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:990}.pull-right>.dropdown-menu{right:0;left:auto}.dropup .caret,.navbar-fixed-bottom .dropdown .caret{content:"";border-top:0;border-bottom:4px dashed;border-bottom:4px solid\9}.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:2px}@media (min-width:768px){.navbar-right .dropdown-menu{right:0;left:auto}.navbar-right .dropdown-menu-left{right:auto;left:0}}.btn-group,.btn-group-vertical{position:relative;display:inline-block;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;float:left}.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:2}.btn-group .btn+.btn,.btn-group .btn+.btn-group,.btn-group .btn-group+.btn,.btn-group .btn-group+.btn-group{margin-left:-1px}.btn-toolbar{margin-left:-5px}.btn-toolbar .btn,.btn-toolbar .btn-group,.btn-toolbar .input-group{float:left}.btn-toolbar>.btn,.btn-toolbar>.btn-group,.btn-toolbar>.input-group{margin-left:5px}.btn-group>.btn:not(:first-child):not(:last-child):not(.dropdown-toggle){border-radius:0}.btn-group>.btn:first-child{margin-left:0}.btn-group>.btn:first-child:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn:last-child:not(:first-child),.btn-group>.dropdown-toggle:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.btn-group>.btn-group{float:left}.btn-group>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-bottom-left-radius:0}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn-group>.btn+.dropdown-toggle{padding-right:8px;padding-left:8px}.btn-group>.btn-lg+.dropdown-toggle{padding-right:12px;padding-left:12px}.btn-group.open .dropdown-toggle{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-group.open .dropdown-toggle.btn-link{-webkit-box-shadow:none;box-shadow:none}.btn .caret{margin-left:0}.btn-lg .caret{border-width:5px 5px 0;border-bottom-width:0}.dropup .btn-lg .caret{border-width:0 5px 5px}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group,.btn-group-vertical>.btn-group>.btn{display:block;float:none;width:100%;max-width:100%}.btn-group-vertical>.btn-group>.btn{float:none}.btn-group-vertical>.btn+.btn,.btn-group-vertical>.btn+.btn-group,.btn-group-vertical>.btn-group+.btn,.btn-group-vertical>.btn-group+.btn-group{margin-top:-1px;margin-left:0}.btn-group-vertical>.btn:not(:first-child):not(:last-child){border-radius:0}.btn-group-vertical>.btn:first-child:not(:last-child){border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn:last-child:not(:first-child){border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.btn-group-vertical>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group-vertical>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group-vertical>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-top-right-radius:0}.btn-group-justified{display:table;width:100%;table-layout:fixed;border-collapse:separate}.btn-group-justified>.btn,.btn-group-justified>.btn-group{display:table-cell;float:none;width:1%}.btn-group-justified>.btn-group .btn{width:100%}.btn-group-justified>.btn-group .dropdown-menu{left:auto}[data-toggle=buttons]>.btn input[type=checkbox],[data-toggle=buttons]>.btn input[type=radio],[data-toggle=buttons]>.btn-group>.btn input[type=checkbox],[data-toggle=buttons]>.btn-group>.btn input[type=radio]{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.input-group{position:relative;display:table;border-collapse:separate}.input-group[class*=col-]{float:none;padding-right:0;padding-left:0}.input-group .form-control{position:relative;z-index:2;float:left;width:100%;margin-bottom:0}.input-group .form-control:focus{z-index:3}.input-group-lg>.form-control,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.btn{height:46px;padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}select.input-group-lg>.form-control,select.input-group-lg>.input-group-addon,select.input-group-lg>.input-group-btn>.btn{height:46px;line-height:46px}select[multiple].input-group-lg>.form-control,select[multiple].input-group-lg>.input-group-addon,select[multiple].input-group-lg>.input-group-btn>.btn,textarea.input-group-lg>.form-control,textarea.input-group-lg>.input-group-addon,textarea.input-group-lg>.input-group-btn>.btn{height:auto}.input-group-sm>.form-control,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.btn{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}select.input-group-sm>.form-control,select.input-group-sm>.input-group-addon,select.input-group-sm>.input-group-btn>.btn{height:30px;line-height:30px}select[multiple].input-group-sm>.form-control,select[multiple].input-group-sm>.input-group-addon,select[multiple].input-group-sm>.input-group-btn>.btn,textarea.input-group-sm>.form-control,textarea.input-group-sm>.input-group-addon,textarea.input-group-sm>.input-group-btn>.btn{height:auto}.input-group .form-control,.input-group-addon,.input-group-btn{display:table-cell}.input-group .form-control:not(:first-child):not(:last-child),.input-group-addon:not(:first-child):not(:last-child),.input-group-btn:not(:first-child):not(:last-child){border-radius:0}.input-group-addon,.input-group-btn{width:1%;white-space:nowrap;vertical-align:middle}.input-group-addon{padding:6px 12px;font-size:14px;font-weight:400;line-height:1;color:#555;text-align:center;background-color:#eee;border:1px solid #ccc;border-radius:4px}.input-group-addon.input-sm{padding:5px 10px;font-size:12px;border-radius:3px}.input-group-addon.input-lg{padding:10px 16px;font-size:18px;border-radius:6px}.input-group-addon input[type=checkbox],.input-group-addon input[type=radio]{margin-top:0}.input-group .form-control:first-child,.input-group-addon:first-child,.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group>.btn,.input-group-btn:first-child>.dropdown-toggle,.input-group-btn:last-child>.btn-group:not(:last-child)>.btn,.input-group-btn:last-child>.btn:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.input-group-addon:first-child{border-right:0}.input-group .form-control:last-child,.input-group-addon:last-child,.input-group-btn:first-child>.btn-group:not(:first-child)>.btn,.input-group-btn:first-child>.btn:not(:first-child),.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group>.btn,.input-group-btn:last-child>.dropdown-toggle{border-top-left-radius:0;border-bottom-left-radius:0}.input-group-addon:last-child{border-left:0}.input-group-btn{position:relative;font-size:0;white-space:nowrap}.input-group-btn>.btn{position:relative}.input-group-btn>.btn+.btn{margin-left:-1px}.input-group-btn>.btn:active,.input-group-btn>.btn:focus,.input-group-btn>.btn:hover{z-index:2}.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group{margin-right:-1px}.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group{z-index:2;margin-left:-1px}.nav{padding-left:0;margin-bottom:0;list-style:none}.nav>li{position:relative;display:block}.nav>li>a{position:relative;display:block;padding:10px 15px}.nav>li>a:focus,.nav>li>a:hover{text-decoration:none;background-color:#eee}.nav>li.disabled>a{color:#777}.nav>li.disabled>a:focus,.nav>li.disabled>a:hover{color:#777;text-decoration:none;cursor:not-allowed;background-color:transparent}.nav .open>a,.nav .open>a:focus,.nav .open>a:hover{background-color:#eee;border-color:#337ab7}.nav .nav-divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.nav>li>a>img{max-width:none}.nav-tabs{border-bottom:1px solid #ddd}.nav-tabs>li{float:left;margin-bottom:-1px}.nav-tabs>li>a{margin-right:2px;line-height:1.42857143;border:1px solid transparent;border-radius:4px 4px 0 0}.nav-tabs>li>a:hover{border-color:#eee #eee #ddd}.nav-tabs>li.active>a,.nav-tabs>li.active>a:focus,.nav-tabs>li.active>a:hover{color:#555;cursor:default;background-color:#fff;border:1px solid #ddd;border-bottom-color:transparent}.nav-tabs.nav-justified{width:100%;border-bottom:0}.nav-tabs.nav-justified>li{float:none}.nav-tabs.nav-justified>li>a{margin-bottom:5px;text-align:center}.nav-tabs.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-tabs.nav-justified>li{display:table-cell;width:1%}.nav-tabs.nav-justified>li>a{margin-bottom:0}}.nav-tabs.nav-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border:1px solid #ddd}@media (min-width:768px){.nav-tabs.nav-justified>li>a{border-bottom:1px solid #ddd;border-radius:4px 4px 0 0}.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border-bottom-color:#fff}}.nav-pills>li{float:left}.nav-pills>li>a{border-radius:4px}.nav-pills>li+li{margin-left:2px}.nav-pills>li.active>a,.nav-pills>li.active>a:focus,.nav-pills>li.active>a:hover{color:#fff;background-color:#337ab7}.nav-stacked>li{float:none}.nav-stacked>li+li{margin-top:2px;margin-left:0}.nav-justified{width:100%}.nav-justified>li{float:none}.nav-justified>li>a{margin-bottom:5px;text-align:center}.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-justified>li{display:table-cell;width:1%}.nav-justified>li>a{margin-bottom:0}}.nav-tabs-justified{border-bottom:0}.nav-tabs-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover{border:1px solid #ddd}@media (min-width:768px){.nav-tabs-justified>li>a{border-bottom:1px solid #ddd;border-radius:4px 4px 0 0}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover{border-bottom-color:#fff}}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-left-radius:0;border-top-right-radius:0}.navbar{position:relative;min-height:50px;margin-bottom:20px;border:1px solid transparent}@media (min-width:768px){.navbar{border-radius:4px}}@media (min-width:768px){.navbar-header{float:left}}.navbar-collapse{padding-right:15px;padding-left:15px;overflow-x:visible;border-top:1px solid transparent;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.1);box-shadow:inset 0 1px 0 rgba(255,255,255,.1);-webkit-overflow-scrolling:touch}.navbar-collapse.in{overflow-y:auto}@media (min-width:768px){.navbar-collapse{width:auto;border-top:0;-webkit-box-shadow:none;box-shadow:none}.navbar-collapse.collapse{display:block!important;height:auto!important;padding-bottom:0;overflow:visible!important}.navbar-collapse.in{overflow-y:visible}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse,.navbar-static-top .navbar-collapse{padding-right:0;padding-left:0}}.navbar-fixed-bottom,.navbar-fixed-top{position:fixed;right:0;left:0;z-index:1030}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:340px}@media (max-device-width:480px) and (orientation:landscape){.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:200px}}@media (min-width:768px){.navbar-fixed-bottom,.navbar-fixed-top{border-radius:0}}.navbar-fixed-top{top:0;border-width:0 0 1px}.navbar-fixed-bottom{bottom:0;margin-bottom:0;border-width:1px 0 0}.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:-15px;margin-left:-15px}@media (min-width:768px){.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:0;margin-left:0}}.navbar-static-top{z-index:1000;border-width:0 0 1px}@media (min-width:768px){.navbar-static-top{border-radius:0}}.navbar-brand{float:left;height:50px;padding:15px 15px;font-size:18px;line-height:20px}.navbar-brand:focus,.navbar-brand:hover{text-decoration:none}.navbar-brand>img{display:block}@media (min-width:768px){.navbar>.container .navbar-brand,.navbar>.container-fluid .navbar-brand{margin-left:-15px}}.navbar-toggle{position:relative;float:right;padding:9px 10px;margin-right:15px;margin-top:8px;margin-bottom:8px;background-color:transparent;background-image:none;border:1px solid transparent;border-radius:4px}.navbar-toggle:focus{outline:0}.navbar-toggle .icon-bar{display:block;width:22px;height:2px;border-radius:1px}.navbar-toggle .icon-bar+.icon-bar{margin-top:4px}@media (min-width:768px){.navbar-toggle{display:none}}.navbar-nav{margin:7.5px -15px}.navbar-nav>li>a{padding-top:10px;padding-bottom:10px;line-height:20px}@media (max-width:767px){.navbar-nav .open .dropdown-menu{position:static;float:none;width:auto;margin-top:0;background-color:transparent;border:0;-webkit-box-shadow:none;box-shadow:none}.navbar-nav .open .dropdown-menu .dropdown-header,.navbar-nav .open .dropdown-menu>li>a{padding:5px 15px 5px 25px}.navbar-nav .open .dropdown-menu>li>a{line-height:20px}.navbar-nav .open .dropdown-menu>li>a:focus,.navbar-nav .open .dropdown-menu>li>a:hover{background-image:none}}@media (min-width:768px){.navbar-nav{float:left;margin:0}.navbar-nav>li{float:left}.navbar-nav>li>a{padding-top:15px;padding-bottom:15px}}.navbar-form{padding:10px 15px;margin-right:-15px;margin-left:-15px;border-top:1px solid transparent;border-bottom:1px solid transparent;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.1),0 1px 0 rgba(255,255,255,.1);box-shadow:inset 0 1px 0 rgba(255,255,255,.1),0 1px 0 rgba(255,255,255,.1);margin-top:8px;margin-bottom:8px}@media (min-width:768px){.navbar-form .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.navbar-form .form-control{display:inline-block;width:auto;vertical-align:middle}.navbar-form .form-control-static{display:inline-block}.navbar-form .input-group{display:inline-table;vertical-align:middle}.navbar-form .input-group .form-control,.navbar-form .input-group .input-group-addon,.navbar-form .input-group .input-group-btn{width:auto}.navbar-form .input-group>.form-control{width:100%}.navbar-form .control-label{margin-bottom:0;vertical-align:middle}.navbar-form .checkbox,.navbar-form .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.navbar-form .checkbox label,.navbar-form .radio label{padding-left:0}.navbar-form .checkbox input[type=checkbox],.navbar-form .radio input[type=radio]{position:relative;margin-left:0}.navbar-form .has-feedback .form-control-feedback{top:0}}@media (max-width:767px){.navbar-form .form-group{margin-bottom:5px}.navbar-form .form-group:last-child{margin-bottom:0}}@media (min-width:768px){.navbar-form{width:auto;padding-top:0;padding-bottom:0;margin-right:0;margin-left:0;border:0;-webkit-box-shadow:none;box-shadow:none}}.navbar-nav>li>.dropdown-menu{margin-top:0;border-top-left-radius:0;border-top-right-radius:0}.navbar-fixed-bottom .navbar-nav>li>.dropdown-menu{margin-bottom:0;border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.navbar-btn{margin-top:8px;margin-bottom:8px}.navbar-btn.btn-sm{margin-top:10px;margin-bottom:10px}.navbar-btn.btn-xs{margin-top:14px;margin-bottom:14px}.navbar-text{margin-top:15px;margin-bottom:15px}@media (min-width:768px){.navbar-text{float:left;margin-right:15px;margin-left:15px}}@media (min-width:768px){.navbar-left{float:left!important}.navbar-right{float:right!important;margin-right:-15px}.navbar-right~.navbar-right{margin-right:0}}.navbar-default{background-color:#f8f8f8;border-color:#e7e7e7}.navbar-default .navbar-brand{color:#777}.navbar-default .navbar-brand:focus,.navbar-default .navbar-brand:hover{color:#5e5e5e;background-color:transparent}.navbar-default .navbar-text{color:#777}.navbar-default .navbar-nav>li>a{color:#777}.navbar-default .navbar-nav>li>a:focus,.navbar-default .navbar-nav>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav>.active>a,.navbar-default .navbar-nav>.active>a:focus,.navbar-default .navbar-nav>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav>.disabled>a,.navbar-default .navbar-nav>.disabled>a:focus,.navbar-default .navbar-nav>.disabled>a:hover{color:#ccc;background-color:transparent}.navbar-default .navbar-nav>.open>a,.navbar-default .navbar-nav>.open>a:focus,.navbar-default .navbar-nav>.open>a:hover{color:#555;background-color:#e7e7e7}@media (max-width:767px){.navbar-default .navbar-nav .open .dropdown-menu>li>a{color:#777}.navbar-default .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav .open .dropdown-menu>.active>a,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#ccc;background-color:transparent}}.navbar-default .navbar-toggle{border-color:#ddd}.navbar-default .navbar-toggle:focus,.navbar-default .navbar-toggle:hover{background-color:#ddd}.navbar-default .navbar-toggle .icon-bar{background-color:#888}.navbar-default .navbar-collapse,.navbar-default .navbar-form{border-color:#e7e7e7}.navbar-default .navbar-link{color:#777}.navbar-default .navbar-link:hover{color:#333}.navbar-default .btn-link{color:#777}.navbar-default .btn-link:focus,.navbar-default .btn-link:hover{color:#333}.navbar-default .btn-link[disabled]:focus,.navbar-default .btn-link[disabled]:hover,fieldset[disabled] .navbar-default .btn-link:focus,fieldset[disabled] .navbar-default .btn-link:hover{color:#ccc}.navbar-inverse{background-color:#222;border-color:#080808}.navbar-inverse .navbar-brand{color:#9d9d9d}.navbar-inverse .navbar-brand:focus,.navbar-inverse .navbar-brand:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-text{color:#9d9d9d}.navbar-inverse .navbar-nav>li>a{color:#9d9d9d}.navbar-inverse .navbar-nav>li>a:focus,.navbar-inverse .navbar-nav>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav>.active>a,.navbar-inverse .navbar-nav>.active>a:focus,.navbar-inverse .navbar-nav>.active>a:hover{color:#fff;background-color:#080808}.navbar-inverse .navbar-nav>.disabled>a,.navbar-inverse .navbar-nav>.disabled>a:focus,.navbar-inverse .navbar-nav>.disabled>a:hover{color:#444;background-color:transparent}.navbar-inverse .navbar-nav>.open>a,.navbar-inverse .navbar-nav>.open>a:focus,.navbar-inverse .navbar-nav>.open>a:hover{color:#fff;background-color:#080808}@media (max-width:767px){.navbar-inverse .navbar-nav .open .dropdown-menu>.dropdown-header{border-color:#080808}.navbar-inverse .navbar-nav .open .dropdown-menu .divider{background-color:#080808}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a{color:#9d9d9d}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:hover{color:#fff;background-color:#080808}.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#444;background-color:transparent}}.navbar-inverse .navbar-toggle{border-color:#333}.navbar-inverse .navbar-toggle:focus,.navbar-inverse .navbar-toggle:hover{background-color:#333}.navbar-inverse .navbar-toggle .icon-bar{background-color:#fff}.navbar-inverse .navbar-collapse,.navbar-inverse .navbar-form{border-color:#101010}.navbar-inverse .navbar-link{color:#9d9d9d}.navbar-inverse .navbar-link:hover{color:#fff}.navbar-inverse .btn-link{color:#9d9d9d}.navbar-inverse .btn-link:focus,.navbar-inverse .btn-link:hover{color:#fff}.navbar-inverse .btn-link[disabled]:focus,.navbar-inverse .btn-link[disabled]:hover,fieldset[disabled] .navbar-inverse .btn-link:focus,fieldset[disabled] .navbar-inverse .btn-link:hover{color:#444}.breadcrumb{padding:8px 15px;margin-bottom:20px;list-style:none;background-color:#f5f5f5;border-radius:4px}.breadcrumb>li{display:inline-block}.breadcrumb>li+li:before{padding:0 5px;color:#ccc;content:"/\00a0"}.breadcrumb>.active{color:#777}.pagination{display:inline-block;padding-left:0;margin:20px 0;border-radius:4px}.pagination>li{display:inline}.pagination>li>a,.pagination>li>span{position:relative;float:left;padding:6px 12px;margin-left:-1px;line-height:1.42857143;color:#337ab7;text-decoration:none;background-color:#fff;border:1px solid #ddd}.pagination>li>a:focus,.pagination>li>a:hover,.pagination>li>span:focus,.pagination>li>span:hover{z-index:2;color:#23527c;background-color:#eee;border-color:#ddd}.pagination>li:first-child>a,.pagination>li:first-child>span{margin-left:0;border-top-left-radius:4px;border-bottom-left-radius:4px}.pagination>li:last-child>a,.pagination>li:last-child>span{border-top-right-radius:4px;border-bottom-right-radius:4px}.pagination>.active>a,.pagination>.active>a:focus,.pagination>.active>a:hover,.pagination>.active>span,.pagination>.active>span:focus,.pagination>.active>span:hover{z-index:3;color:#fff;cursor:default;background-color:#337ab7;border-color:#337ab7}.pagination>.disabled>a,.pagination>.disabled>a:focus,.pagination>.disabled>a:hover,.pagination>.disabled>span,.pagination>.disabled>span:focus,.pagination>.disabled>span:hover{color:#777;cursor:not-allowed;background-color:#fff;border-color:#ddd}.pagination-lg>li>a,.pagination-lg>li>span{padding:10px 16px;font-size:18px;line-height:1.3333333}.pagination-lg>li:first-child>a,.pagination-lg>li:first-child>span{border-top-left-radius:6px;border-bottom-left-radius:6px}.pagination-lg>li:last-child>a,.pagination-lg>li:last-child>span{border-top-right-radius:6px;border-bottom-right-radius:6px}.pagination-sm>li>a,.pagination-sm>li>span{padding:5px 10px;font-size:12px;line-height:1.5}.pagination-sm>li:first-child>a,.pagination-sm>li:first-child>span{border-top-left-radius:3px;border-bottom-left-radius:3px}.pagination-sm>li:last-child>a,.pagination-sm>li:last-child>span{border-top-right-radius:3px;border-bottom-right-radius:3px}.pager{padding-left:0;margin:20px 0;text-align:center;list-style:none}.pager li{display:inline}.pager li>a,.pager li>span{display:inline-block;padding:5px 14px;background-color:#fff;border:1px solid #ddd;border-radius:15px}.pager li>a:focus,.pager li>a:hover{text-decoration:none;background-color:#eee}.pager .next>a,.pager .next>span{float:right}.pager .previous>a,.pager .previous>span{float:left}.pager .disabled>a,.pager .disabled>a:focus,.pager .disabled>a:hover,.pager .disabled>span{color:#777;cursor:not-allowed;background-color:#fff}.label{display:inline;padding:.2em .6em .3em;font-size:75%;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25em}a.label:focus,a.label:hover{color:#fff;text-decoration:none;cursor:pointer}.label:empty{display:none}.btn .label{position:relative;top:-1px}.label-default{background-color:#777}.label-default[href]:focus,.label-default[href]:hover{background-color:#5e5e5e}.label-primary{background-color:#337ab7}.label-primary[href]:focus,.label-primary[href]:hover{background-color:#286090}.label-success{background-color:#5cb85c}.label-success[href]:focus,.label-success[href]:hover{background-color:#449d44}.label-info{background-color:#5bc0de}.label-info[href]:focus,.label-info[href]:hover{background-color:#31b0d5}.label-warning{background-color:#f0ad4e}.label-warning[href]:focus,.label-warning[href]:hover{background-color:#ec971f}.label-danger{background-color:#d9534f}.label-danger[href]:focus,.label-danger[href]:hover{background-color:#c9302c}.badge{display:inline-block;min-width:10px;padding:3px 7px;font-size:12px;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:middle;background-color:#777;border-radius:10px}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.btn-group-xs>.btn .badge,.btn-xs .badge{top:0;padding:1px 5px}a.badge:focus,a.badge:hover{color:#fff;text-decoration:none;cursor:pointer}.list-group-item.active>.badge,.nav-pills>.active>a>.badge{color:#337ab7;background-color:#fff}.list-group-item>.badge{float:right}.list-group-item>.badge+.badge{margin-right:5px}.nav-pills>li>a>.badge{margin-left:3px}.jumbotron{padding-top:30px;padding-bottom:30px;margin-bottom:30px;color:inherit;background-color:#eee}.jumbotron .h1,.jumbotron h1{color:inherit}.jumbotron p{margin-bottom:15px;font-size:21px;font-weight:200}.jumbotron>hr{border-top-color:#d5d5d5}.container .jumbotron,.container-fluid .jumbotron{padding-right:15px;padding-left:15px;border-radius:6px}.jumbotron .container{max-width:100%}@media screen and (min-width:768px){.jumbotron{padding-top:48px;padding-bottom:48px}.container .jumbotron,.container-fluid .jumbotron{padding-right:60px;padding-left:60px}.jumbotron .h1,.jumbotron h1{font-size:63px}}.thumbnail{display:block;padding:4px;margin-bottom:20px;line-height:1.42857143;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:border .2s ease-in-out;-o-transition:border .2s ease-in-out;transition:border .2s ease-in-out}.thumbnail a>img,.thumbnail>img{margin-right:auto;margin-left:auto}a.thumbnail.active,a.thumbnail:focus,a.thumbnail:hover{border-color:#337ab7}.thumbnail .caption{padding:9px;color:#333}.alert{padding:15px;margin-bottom:20px;border:1px solid transparent;border-radius:4px}.alert h4{margin-top:0;color:inherit}.alert .alert-link{font-weight:700}.alert>p,.alert>ul{margin-bottom:0}.alert>p+p{margin-top:5px}.alert-dismissable,.alert-dismissible{padding-right:35px}.alert-dismissable .close,.alert-dismissible .close{position:relative;top:-2px;right:-21px;color:inherit}.alert-success{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.alert-success hr{border-top-color:#c9e2b3}.alert-success .alert-link{color:#2b542c}.alert-info{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.alert-info hr{border-top-color:#a6e1ec}.alert-info .alert-link{color:#245269}.alert-warning{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.alert-warning hr{border-top-color:#f7e1b5}.alert-warning .alert-link{color:#66512c}.alert-danger{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.alert-danger hr{border-top-color:#e4b9c0}.alert-danger .alert-link{color:#843534}@-webkit-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-o-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}.progress{height:20px;margin-bottom:20px;overflow:hidden;background-color:#f5f5f5;border-radius:4px;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,.1);box-shadow:inset 0 1px 2px rgba(0,0,0,.1)}.progress-bar{float:left;width:0%;height:100%;font-size:12px;line-height:20px;color:#fff;text-align:center;background-color:#337ab7;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);-webkit-transition:width .6s ease;-o-transition:width .6s ease;transition:width .6s ease}.progress-bar-striped,.progress-striped .progress-bar{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);-webkit-background-size:40px 40px;background-size:40px 40px}.progress-bar.active,.progress.active .progress-bar{-webkit-animation:progress-bar-stripes 2s linear infinite;-o-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite}.progress-bar-success{background-color:#5cb85c}.progress-striped .progress-bar-success{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.progress-bar-info{background-color:#5bc0de}.progress-striped .progress-bar-info{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.progress-bar-warning{background-color:#f0ad4e}.progress-striped .progress-bar-warning{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.progress-bar-danger{background-color:#d9534f}.progress-striped .progress-bar-danger{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.media{margin-top:15px}.media:first-child{margin-top:0}.media,.media-body{overflow:hidden;zoom:1}.media-body{width:10000px}.media-object{display:block}.media-object.img-thumbnail{max-width:none}.media-right,.media>.pull-right{padding-left:10px}.media-left,.media>.pull-left{padding-right:10px}.media-body,.media-left,.media-right{display:table-cell;vertical-align:top}.media-middle{vertical-align:middle}.media-bottom{vertical-align:bottom}.media-heading{margin-top:0;margin-bottom:5px}.media-list{padding-left:0;list-style:none}.list-group{padding-left:0;margin-bottom:20px}.list-group-item{position:relative;display:block;padding:10px 15px;margin-bottom:-1px;background-color:#fff;border:1px solid #ddd}.list-group-item:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.list-group-item:last-child{margin-bottom:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.list-group-item.disabled,.list-group-item.disabled:focus,.list-group-item.disabled:hover{color:#777;cursor:not-allowed;background-color:#eee}.list-group-item.disabled .list-group-item-heading,.list-group-item.disabled:focus .list-group-item-heading,.list-group-item.disabled:hover .list-group-item-heading{color:inherit}.list-group-item.disabled .list-group-item-text,.list-group-item.disabled:focus .list-group-item-text,.list-group-item.disabled:hover .list-group-item-text{color:#777}.list-group-item.active,.list-group-item.active:focus,.list-group-item.active:hover{z-index:2;color:#fff;background-color:#337ab7;border-color:#337ab7}.list-group-item.active .list-group-item-heading,.list-group-item.active .list-group-item-heading>.small,.list-group-item.active .list-group-item-heading>small,.list-group-item.active:focus .list-group-item-heading,.list-group-item.active:focus .list-group-item-heading>.small,.list-group-item.active:focus .list-group-item-heading>small,.list-group-item.active:hover .list-group-item-heading,.list-group-item.active:hover .list-group-item-heading>.small,.list-group-item.active:hover .list-group-item-heading>small{color:inherit}.list-group-item.active .list-group-item-text,.list-group-item.active:focus .list-group-item-text,.list-group-item.active:hover .list-group-item-text{color:#c7ddef}a.list-group-item,button.list-group-item{color:#555}a.list-group-item .list-group-item-heading,button.list-group-item .list-group-item-heading{color:#333}a.list-group-item:focus,a.list-group-item:hover,button.list-group-item:focus,button.list-group-item:hover{color:#555;text-decoration:none;background-color:#f5f5f5}button.list-group-item{width:100%;text-align:left}.list-group-item-success{color:#3c763d;background-color:#dff0d8}a.list-group-item-success,button.list-group-item-success{color:#3c763d}a.list-group-item-success .list-group-item-heading,button.list-group-item-success .list-group-item-heading{color:inherit}a.list-group-item-success:focus,a.list-group-item-success:hover,button.list-group-item-success:focus,button.list-group-item-success:hover{color:#3c763d;background-color:#d0e9c6}a.list-group-item-success.active,a.list-group-item-success.active:focus,a.list-group-item-success.active:hover,button.list-group-item-success.active,button.list-group-item-success.active:focus,button.list-group-item-success.active:hover{color:#fff;background-color:#3c763d;border-color:#3c763d}.list-group-item-info{color:#31708f;background-color:#d9edf7}a.list-group-item-info,button.list-group-item-info{color:#31708f}a.list-group-item-info .list-group-item-heading,button.list-group-item-info .list-group-item-heading{color:inherit}a.list-group-item-info:focus,a.list-group-item-info:hover,button.list-group-item-info:focus,button.list-group-item-info:hover{color:#31708f;background-color:#c4e3f3}a.list-group-item-info.active,a.list-group-item-info.active:focus,a.list-group-item-info.active:hover,button.list-group-item-info.active,button.list-group-item-info.active:focus,button.list-group-item-info.active:hover{color:#fff;background-color:#31708f;border-color:#31708f}.list-group-item-warning{color:#8a6d3b;background-color:#fcf8e3}a.list-group-item-warning,button.list-group-item-warning{color:#8a6d3b}a.list-group-item-warning .list-group-item-heading,button.list-group-item-warning .list-group-item-heading{color:inherit}a.list-group-item-warning:focus,a.list-group-item-warning:hover,button.list-group-item-warning:focus,button.list-group-item-warning:hover{color:#8a6d3b;background-color:#faf2cc}a.list-group-item-warning.active,a.list-group-item-warning.active:focus,a.list-group-item-warning.active:hover,button.list-group-item-warning.active,button.list-group-item-warning.active:focus,button.list-group-item-warning.active:hover{color:#fff;background-color:#8a6d3b;border-color:#8a6d3b}.list-group-item-danger{color:#a94442;background-color:#f2dede}a.list-group-item-danger,button.list-group-item-danger{color:#a94442}a.list-group-item-danger .list-group-item-heading,button.list-group-item-danger .list-group-item-heading{color:inherit}a.list-group-item-danger:focus,a.list-group-item-danger:hover,button.list-group-item-danger:focus,button.list-group-item-danger:hover{color:#a94442;background-color:#ebcccc}a.list-group-item-danger.active,a.list-group-item-danger.active:focus,a.list-group-item-danger.active:hover,button.list-group-item-danger.active,button.list-group-item-danger.active:focus,button.list-group-item-danger.active:hover{color:#fff;background-color:#a94442;border-color:#a94442}.list-group-item-heading{margin-top:0;margin-bottom:5px}.list-group-item-text{margin-bottom:0;line-height:1.3}.panel{margin-bottom:20px;background-color:#fff;border:1px solid transparent;border-radius:4px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.panel-body{padding:15px}.panel-heading{padding:10px 15px;border-bottom:1px solid transparent;border-top-left-radius:3px;border-top-right-radius:3px}.panel-heading>.dropdown .dropdown-toggle{color:inherit}.panel-title{margin-top:0;margin-bottom:0;font-size:16px;color:inherit}.panel-title>.small,.panel-title>.small>a,.panel-title>a,.panel-title>small,.panel-title>small>a{color:inherit}.panel-footer{padding:10px 15px;background-color:#f5f5f5;border-top:1px solid #ddd;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.list-group,.panel>.panel-collapse>.list-group{margin-bottom:0}.panel>.list-group .list-group-item,.panel>.panel-collapse>.list-group .list-group-item{border-width:1px 0;border-radius:0}.panel>.list-group:first-child .list-group-item:first-child,.panel>.panel-collapse>.list-group:first-child .list-group-item:first-child{border-top:0;border-top-left-radius:3px;border-top-right-radius:3px}.panel>.list-group:last-child .list-group-item:last-child,.panel>.panel-collapse>.list-group:last-child .list-group-item:last-child{border-bottom:0;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.panel-heading+.panel-collapse>.list-group .list-group-item:first-child{border-top-left-radius:0;border-top-right-radius:0}.panel-heading+.list-group .list-group-item:first-child{border-top-width:0}.list-group+.panel-footer{border-top-width:0}.panel>.panel-collapse>.table,.panel>.table,.panel>.table-responsive>.table{margin-bottom:0}.panel>.panel-collapse>.table caption,.panel>.table caption,.panel>.table-responsive>.table caption{padding-right:15px;padding-left:15px}.panel>.table-responsive:first-child>.table:first-child,.panel>.table:first-child{border-top-left-radius:3px;border-top-right-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child,.panel>.table:first-child>thead:first-child>tr:first-child{border-top-left-radius:3px;border-top-right-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table:first-child>thead:first-child>tr:first-child th:first-child{border-top-left-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table:first-child>thead:first-child>tr:first-child th:last-child{border-top-right-radius:3px}.panel>.table-responsive:last-child>.table:last-child,.panel>.table:last-child{border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child{border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:first-child{border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:last-child{border-bottom-right-radius:3px}.panel>.panel-body+.table,.panel>.panel-body+.table-responsive,.panel>.table+.panel-body,.panel>.table-responsive+.panel-body{border-top:1px solid #ddd}.panel>.table>tbody:first-child>tr:first-child td,.panel>.table>tbody:first-child>tr:first-child th{border-top:0}.panel>.table-bordered,.panel>.table-responsive>.table-bordered{border:0}.panel>.table-bordered>tbody>tr>td:first-child,.panel>.table-bordered>tbody>tr>th:first-child,.panel>.table-bordered>tfoot>tr>td:first-child,.panel>.table-bordered>tfoot>tr>th:first-child,.panel>.table-bordered>thead>tr>td:first-child,.panel>.table-bordered>thead>tr>th:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:first-child,.panel>.table-responsive>.table-bordered>thead>tr>td:first-child,.panel>.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.panel>.table-bordered>tbody>tr>td:last-child,.panel>.table-bordered>tbody>tr>th:last-child,.panel>.table-bordered>tfoot>tr>td:last-child,.panel>.table-bordered>tfoot>tr>th:last-child,.panel>.table-bordered>thead>tr>td:last-child,.panel>.table-bordered>thead>tr>th:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:last-child,.panel>.table-responsive>.table-bordered>thead>tr>td:last-child,.panel>.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.panel>.table-bordered>tbody>tr:first-child>td,.panel>.table-bordered>tbody>tr:first-child>th,.panel>.table-bordered>thead>tr:first-child>td,.panel>.table-bordered>thead>tr:first-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>th,.panel>.table-responsive>.table-bordered>thead>tr:first-child>td,.panel>.table-responsive>.table-bordered>thead>tr:first-child>th{border-bottom:0}.panel>.table-bordered>tbody>tr:last-child>td,.panel>.table-bordered>tbody>tr:last-child>th,.panel>.table-bordered>tfoot>tr:last-child>td,.panel>.table-bordered>tfoot>tr:last-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>th,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>td,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>th{border-bottom:0}.panel>.table-responsive{margin-bottom:0;border:0}.panel-group{margin-bottom:20px}.panel-group .panel{margin-bottom:0;border-radius:4px}.panel-group .panel+.panel{margin-top:5px}.panel-group .panel-heading{border-bottom:0}.panel-group .panel-heading+.panel-collapse>.list-group,.panel-group .panel-heading+.panel-collapse>.panel-body{border-top:1px solid #ddd}.panel-group .panel-footer{border-top:0}.panel-group .panel-footer+.panel-collapse .panel-body{border-bottom:1px solid #ddd}.panel-default{border-color:#ddd}.panel-default>.panel-heading{color:#333;background-color:#f5f5f5;border-color:#ddd}.panel-default>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ddd}.panel-default>.panel-heading .badge{color:#f5f5f5;background-color:#333}.panel-default>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ddd}.panel-primary{border-color:#337ab7}.panel-primary>.panel-heading{color:#fff;background-color:#337ab7;border-color:#337ab7}.panel-primary>.panel-heading+.panel-collapse>.panel-body{border-top-color:#337ab7}.panel-primary>.panel-heading .badge{color:#337ab7;background-color:#fff}.panel-primary>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#337ab7}.panel-success{border-color:#d6e9c6}.panel-success>.panel-heading{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.panel-success>.panel-heading+.panel-collapse>.panel-body{border-top-color:#d6e9c6}.panel-success>.panel-heading .badge{color:#dff0d8;background-color:#3c763d}.panel-success>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#d6e9c6}.panel-info{border-color:#bce8f1}.panel-info>.panel-heading{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.panel-info>.panel-heading+.panel-collapse>.panel-body{border-top-color:#bce8f1}.panel-info>.panel-heading .badge{color:#d9edf7;background-color:#31708f}.panel-info>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#bce8f1}.panel-warning{border-color:#faebcc}.panel-warning>.panel-heading{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.panel-warning>.panel-heading+.panel-collapse>.panel-body{border-top-color:#faebcc}.panel-warning>.panel-heading .badge{color:#fcf8e3;background-color:#8a6d3b}.panel-warning>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#faebcc}.panel-danger{border-color:#ebccd1}.panel-danger>.panel-heading{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.panel-danger>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ebccd1}.panel-danger>.panel-heading .badge{color:#f2dede;background-color:#a94442}.panel-danger>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ebccd1}.embed-responsive{position:relative;display:block;height:0;padding:0;overflow:hidden}.embed-responsive .embed-responsive-item,.embed-responsive embed,.embed-responsive iframe,.embed-responsive object,.embed-responsive video{position:absolute;top:0;bottom:0;left:0;width:100%;height:100%;border:0}.embed-responsive-16by9{padding-bottom:56.25%}.embed-responsive-4by3{padding-bottom:75%}.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#f5f5f5;border:1px solid #e3e3e3;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.05);box-shadow:inset 0 1px 1px rgba(0,0,0,.05)}.well blockquote{border-color:#ddd;border-color:rgba(0,0,0,.15)}.well-lg{padding:24px;border-radius:6px}.well-sm{padding:9px;border-radius:3px}.close{float:right;font-size:21px;font-weight:700;line-height:1;color:#000;text-shadow:0 1px 0 #fff;filter:alpha(opacity=20);opacity:.2}.close:focus,.close:hover{color:#000;text-decoration:none;cursor:pointer;filter:alpha(opacity=50);opacity:.5}button.close{padding:0;cursor:pointer;background:0 0;border:0;-webkit-appearance:none;-moz-appearance:none;appearance:none}.modal-open{overflow:hidden}.modal{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1050;display:none;overflow:hidden;-webkit-overflow-scrolling:touch;outline:0}.modal.fade .modal-dialog{-webkit-transform:translate(0,-25%);-ms-transform:translate(0,-25%);-o-transform:translate(0,-25%);transform:translate(0,-25%);-webkit-transition:-webkit-transform .3s ease-out;-o-transition:-o-transform .3s ease-out;transition:-webkit-transform .3s ease-out;transition:transform .3s ease-out;transition:transform .3s ease-out,-webkit-transform .3s ease-out,-o-transform .3s ease-out}.modal.in .modal-dialog{-webkit-transform:translate(0,0);-ms-transform:translate(0,0);-o-transform:translate(0,0);transform:translate(0,0)}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal-dialog{position:relative;width:auto;margin:10px}.modal-content{position:relative;background-color:#fff;background-clip:padding-box;border:1px solid #999;border:1px solid rgba(0,0,0,.2);border-radius:6px;-webkit-box-shadow:0 3px 9px rgba(0,0,0,.5);box-shadow:0 3px 9px rgba(0,0,0,.5);outline:0}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000}.modal-backdrop.fade{filter:alpha(opacity=0);opacity:0}.modal-backdrop.in{filter:alpha(opacity=50);opacity:.5}.modal-header{padding:15px;border-bottom:1px solid #e5e5e5}.modal-header .close{margin-top:-2px}.modal-title{margin:0;line-height:1.42857143}.modal-body{position:relative;padding:15px}.modal-footer{padding:15px;text-align:right;border-top:1px solid #e5e5e5}.modal-footer .btn+.btn{margin-bottom:0;margin-left:5px}.modal-footer .btn-group .btn+.btn{margin-left:-1px}.modal-footer .btn-block+.btn-block{margin-left:0}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:768px){.modal-dialog{width:600px;margin:30px auto}.modal-content{-webkit-box-shadow:0 5px 15px rgba(0,0,0,.5);box-shadow:0 5px 15px rgba(0,0,0,.5)}.modal-sm{width:300px}}@media (min-width:992px){.modal-lg{width:900px}}.tooltip{position:absolute;z-index:1070;display:block;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-style:normal;font-weight:400;line-height:1.42857143;line-break:auto;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;font-size:12px;filter:alpha(opacity=0);opacity:0}.tooltip.in{filter:alpha(opacity=90);opacity:.9}.tooltip.top{padding:5px 0;margin-top:-3px}.tooltip.right{padding:0 5px;margin-left:3px}.tooltip.bottom{padding:5px 0;margin-top:3px}.tooltip.left{padding:0 5px;margin-left:-3px}.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-left .tooltip-arrow{right:5px;bottom:0;margin-bottom:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-right .tooltip-arrow{bottom:0;left:5px;margin-bottom:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-width:5px 5px 5px 0;border-right-color:#000}.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-width:5px 0 5px 5px;border-left-color:#000}.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-left .tooltip-arrow{top:0;right:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-right .tooltip-arrow{top:0;left:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip-inner{max-width:200px;padding:3px 8px;color:#fff;text-align:center;background-color:#000;border-radius:4px}.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.popover{position:absolute;top:0;left:0;z-index:1060;display:none;max-width:276px;padding:1px;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-style:normal;font-weight:400;line-height:1.42857143;line-break:auto;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;font-size:14px;background-color:#fff;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.2);border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,.2);box-shadow:0 5px 10px rgba(0,0,0,.2)}.popover.top{margin-top:-10px}.popover.right{margin-left:10px}.popover.bottom{margin-top:10px}.popover.left{margin-left:-10px}.popover>.arrow{border-width:11px}.popover>.arrow,.popover>.arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.popover>.arrow:after{content:"";border-width:10px}.popover.top>.arrow{bottom:-11px;left:50%;margin-left:-11px;border-top-color:#999;border-top-color:rgba(0,0,0,.25);border-bottom-width:0}.popover.top>.arrow:after{bottom:1px;margin-left:-10px;content:" ";border-top-color:#fff;border-bottom-width:0}.popover.right>.arrow{top:50%;left:-11px;margin-top:-11px;border-right-color:#999;border-right-color:rgba(0,0,0,.25);border-left-width:0}.popover.right>.arrow:after{bottom:-10px;left:1px;content:" ";border-right-color:#fff;border-left-width:0}.popover.bottom>.arrow{top:-11px;left:50%;margin-left:-11px;border-top-width:0;border-bottom-color:#999;border-bottom-color:rgba(0,0,0,.25)}.popover.bottom>.arrow:after{top:1px;margin-left:-10px;content:" ";border-top-width:0;border-bottom-color:#fff}.popover.left>.arrow{top:50%;right:-11px;margin-top:-11px;border-right-width:0;border-left-color:#999;border-left-color:rgba(0,0,0,.25)}.popover.left>.arrow:after{right:1px;bottom:-10px;content:" ";border-right-width:0;border-left-color:#fff}.popover-title{padding:8px 14px;margin:0;font-size:14px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-radius:5px 5px 0 0}.popover-content{padding:9px 14px}.carousel{position:relative}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-inner>.item{position:relative;display:none;-webkit-transition:.6s ease-in-out left;-o-transition:.6s ease-in-out left;transition:.6s ease-in-out left}.carousel-inner>.item>a>img,.carousel-inner>.item>img{line-height:1}@media all and (transform-3d),(-webkit-transform-3d){.carousel-inner>.item{-webkit-transition:-webkit-transform .6s ease-in-out;-o-transition:-o-transform .6s ease-in-out;transition:-webkit-transform .6s ease-in-out;transition:transform .6s ease-in-out;transition:transform .6s ease-in-out,-webkit-transform .6s ease-in-out,-o-transform .6s ease-in-out;-webkit-backface-visibility:hidden;backface-visibility:hidden;-webkit-perspective:1000px;perspective:1000px}.carousel-inner>.item.active.right,.carousel-inner>.item.next{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0);left:0}.carousel-inner>.item.active.left,.carousel-inner>.item.prev{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0);left:0}.carousel-inner>.item.active,.carousel-inner>.item.next.left,.carousel-inner>.item.prev.right{-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0);left:0}}.carousel-inner>.active,.carousel-inner>.next,.carousel-inner>.prev{display:block}.carousel-inner>.active{left:0}.carousel-inner>.next,.carousel-inner>.prev{position:absolute;top:0;width:100%}.carousel-inner>.next{left:100%}.carousel-inner>.prev{left:-100%}.carousel-inner>.next.left,.carousel-inner>.prev.right{left:0}.carousel-inner>.active.left{left:-100%}.carousel-inner>.active.right{left:100%}.carousel-control{position:absolute;top:0;bottom:0;left:0;width:15%;font-size:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6);background-color:rgba(0,0,0,0);filter:alpha(opacity=50);opacity:.5}.carousel-control.left{background-image:-webkit-linear-gradient(left,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);background-image:-o-linear-gradient(left,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);background-image:-webkit-gradient(linear,left top,right top,from(rgba(0,0,0,.5)),to(rgba(0,0,0,.0001)));background-image:linear-gradient(to right,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#80000000', endColorstr='#00000000', GradientType=1);background-repeat:repeat-x}.carousel-control.right{right:0;left:auto;background-image:-webkit-linear-gradient(left,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);background-image:-o-linear-gradient(left,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);background-image:-webkit-gradient(linear,left top,right top,from(rgba(0,0,0,.0001)),to(rgba(0,0,0,.5)));background-image:linear-gradient(to right,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#00000000', endColorstr='#80000000', GradientType=1);background-repeat:repeat-x}.carousel-control:focus,.carousel-control:hover{color:#fff;text-decoration:none;outline:0;filter:alpha(opacity=90);opacity:.9}.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{position:absolute;top:50%;z-index:5;display:inline-block;margin-top:-10px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{left:50%;margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{right:50%;margin-right:-10px}.carousel-control .icon-next,.carousel-control .icon-prev{width:20px;height:20px;font-family:serif;line-height:1}.carousel-control .icon-prev:before{content:"\2039"}.carousel-control .icon-next:before{content:"\203a"}.carousel-indicators{position:absolute;bottom:10px;left:50%;z-index:15;width:60%;padding-left:0;margin-left:-30%;text-align:center;list-style:none}.carousel-indicators li{display:inline-block;width:10px;height:10px;margin:1px;text-indent:-999px;cursor:pointer;background-color:#000\9;background-color:rgba(0,0,0,0);border:1px solid #fff;border-radius:10px}.carousel-indicators .active{width:12px;height:12px;margin:0;background-color:#fff}.carousel-caption{position:absolute;right:15%;bottom:20px;left:15%;z-index:10;padding-top:20px;padding-bottom:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6)}.carousel-caption .btn{text-shadow:none}@media screen and (min-width:768px){.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{width:30px;height:30px;margin-top:-10px;font-size:30px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{margin-right:-10px}.carousel-caption{right:20%;left:20%;padding-bottom:30px}.carousel-indicators{bottom:20px}}.btn-group-vertical>.btn-group:after,.btn-group-vertical>.btn-group:before,.btn-toolbar:after,.btn-toolbar:before,.clearfix:after,.clearfix:before,.container-fluid:after,.container-fluid:before,.container:after,.container:before,.dl-horizontal dd:after,.dl-horizontal dd:before,.form-horizontal .form-group:after,.form-horizontal .form-group:before,.modal-footer:after,.modal-footer:before,.modal-header:after,.modal-header:before,.nav:after,.nav:before,.navbar-collapse:after,.navbar-collapse:before,.navbar-header:after,.navbar-header:before,.navbar:after,.navbar:before,.pager:after,.pager:before,.panel-body:after,.panel-body:before,.row:after,.row:before{display:table;content:" "}.btn-group-vertical>.btn-group:after,.btn-toolbar:after,.clearfix:after,.container-fluid:after,.container:after,.dl-horizontal dd:after,.form-horizontal .form-group:after,.modal-footer:after,.modal-header:after,.nav:after,.navbar-collapse:after,.navbar-header:after,.navbar:after,.pager:after,.panel-body:after,.row:after{clear:both}.center-block{display:block;margin-right:auto;margin-left:auto}.pull-right{float:right!important}.pull-left{float:left!important}.hide{display:none!important}.show{display:block!important}.invisible{visibility:hidden}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.hidden{display:none!important}.affix{position:fixed}@-ms-viewport{width:device-width}.visible-lg,.visible-md,.visible-sm,.visible-xs{display:none!important}.visible-lg-block,.visible-lg-inline,.visible-lg-inline-block,.visible-md-block,.visible-md-inline,.visible-md-inline-block,.visible-sm-block,.visible-sm-inline,.visible-sm-inline-block,.visible-xs-block,.visible-xs-inline,.visible-xs-inline-block{display:none!important}@media (max-width:767px){.visible-xs{display:block!important}table.visible-xs{display:table!important}tr.visible-xs{display:table-row!important}td.visible-xs,th.visible-xs{display:table-cell!important}}@media (max-width:767px){.visible-xs-block{display:block!important}}@media (max-width:767px){.visible-xs-inline{display:inline!important}}@media (max-width:767px){.visible-xs-inline-block{display:inline-block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm{display:block!important}table.visible-sm{display:table!important}tr.visible-sm{display:table-row!important}td.visible-sm,th.visible-sm{display:table-cell!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-block{display:block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline{display:inline!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline-block{display:inline-block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md{display:block!important}table.visible-md{display:table!important}tr.visible-md{display:table-row!important}td.visible-md,th.visible-md{display:table-cell!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-block{display:block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline{display:inline!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline-block{display:inline-block!important}}@media (min-width:1200px){.visible-lg{display:block!important}table.visible-lg{display:table!important}tr.visible-lg{display:table-row!important}td.visible-lg,th.visible-lg{display:table-cell!important}}@media (min-width:1200px){.visible-lg-block{display:block!important}}@media (min-width:1200px){.visible-lg-inline{display:inline!important}}@media (min-width:1200px){.visible-lg-inline-block{display:inline-block!important}}@media (max-width:767px){.hidden-xs{display:none!important}}@media (min-width:768px) and (max-width:991px){.hidden-sm{display:none!important}}@media (min-width:992px) and (max-width:1199px){.hidden-md{display:none!important}}@media (min-width:1200px){.hidden-lg{display:none!important}}.visible-print{display:none!important}@media print{.visible-print{display:block!important}table.visible-print{display:table!important}tr.visible-print{display:table-row!important}td.visible-print,th.visible-print{display:table-cell!important}}.visible-print-block{display:none!important}@media print{.visible-print-block{display:block!important}}.visible-print-inline{display:none!important}@media print{.visible-print-inline{display:inline!important}}.visible-print-inline-block{display:none!important}@media print{.visible-print-inline-block{display:inline-block!important}}@media print{.hidden-print{display:none!important}}
+/*# sourceMappingURL=bootstrap.min.css.map */
\ No newline at end of file
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/css/hbase.css b/hbase-thrift/src/main/resources/hbase-webapps/static/css/hbase.css
new file mode 100644
index 0000000..03d8ff4
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/css/hbase.css
@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+
+/* General styling */
+body { padding-top: 50px; }
+html .content {
+ margin-left: 2.0em;
+ margin-right: 2.0em;
+}
+.navbar-brand img {
+ margin-top: -7px;
+}
+.inner_header { margin-bottom: 1em;}
+section { margin-bottom: 3em; }
+
+
+/* Master page styling */
+#tab_catalogTables table {
+ /*
+ Catalog tab on master doesn't have any content before
+ it. Make sure there is some padding so it
+ doesn't look crowded.
+ */
+ margin-top: 1.2em;
+}
+
+/* Region Server page styling */
\ No newline at end of file
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.eot b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.eot
new file mode 100644
index 0000000..b93a495
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.eot
Binary files differ
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.svg b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.svg
new file mode 100644
index 0000000..94fb549
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.svg
@@ -0,0 +1,288 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata></metadata>
+<defs>
+<font id="glyphicons_halflingsregular" horiz-adv-x="1200" >
+<font-face units-per-em="1200" ascent="960" descent="-240" />
+<missing-glyph horiz-adv-x="500" />
+<glyph horiz-adv-x="0" />
+<glyph horiz-adv-x="400" />
+<glyph unicode=" " />
+<glyph unicode="*" d="M600 1100q15 0 34 -1.5t30 -3.5l11 -1q10 -2 17.5 -10.5t7.5 -18.5v-224l158 158q7 7 18 8t19 -6l106 -106q7 -8 6 -19t-8 -18l-158 -158h224q10 0 18.5 -7.5t10.5 -17.5q6 -41 6 -75q0 -15 -1.5 -34t-3.5 -30l-1 -11q-2 -10 -10.5 -17.5t-18.5 -7.5h-224l158 -158 q7 -7 8 -18t-6 -19l-106 -106q-8 -7 -19 -6t-18 8l-158 158v-224q0 -10 -7.5 -18.5t-17.5 -10.5q-41 -6 -75 -6q-15 0 -34 1.5t-30 3.5l-11 1q-10 2 -17.5 10.5t-7.5 18.5v224l-158 -158q-7 -7 -18 -8t-19 6l-106 106q-7 8 -6 19t8 18l158 158h-224q-10 0 -18.5 7.5 t-10.5 17.5q-6 41 -6 75q0 15 1.5 34t3.5 30l1 11q2 10 10.5 17.5t18.5 7.5h224l-158 158q-7 7 -8 18t6 19l106 106q8 7 19 6t18 -8l158 -158v224q0 10 7.5 18.5t17.5 10.5q41 6 75 6z" />
+<glyph unicode="+" d="M450 1100h200q21 0 35.5 -14.5t14.5 -35.5v-350h350q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-350v-350q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v350h-350q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5 h350v350q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode=" " />
+<glyph unicode="¥" d="M825 1100h250q10 0 12.5 -5t-5.5 -13l-364 -364q-6 -6 -11 -18h268q10 0 13 -6t-3 -14l-120 -160q-6 -8 -18 -14t-22 -6h-125v-100h275q10 0 13 -6t-3 -14l-120 -160q-6 -8 -18 -14t-22 -6h-125v-174q0 -11 -7.5 -18.5t-18.5 -7.5h-148q-11 0 -18.5 7.5t-7.5 18.5v174 h-275q-10 0 -13 6t3 14l120 160q6 8 18 14t22 6h125v100h-275q-10 0 -13 6t3 14l120 160q6 8 18 14t22 6h118q-5 12 -11 18l-364 364q-8 8 -5.5 13t12.5 5h250q25 0 43 -18l164 -164q8 -8 18 -8t18 8l164 164q18 18 43 18z" />
+<glyph unicode=" " horiz-adv-x="650" />
+<glyph unicode=" " horiz-adv-x="1300" />
+<glyph unicode=" " horiz-adv-x="650" />
+<glyph unicode=" " horiz-adv-x="1300" />
+<glyph unicode=" " horiz-adv-x="433" />
+<glyph unicode=" " horiz-adv-x="325" />
+<glyph unicode=" " horiz-adv-x="216" />
+<glyph unicode=" " horiz-adv-x="216" />
+<glyph unicode=" " horiz-adv-x="162" />
+<glyph unicode=" " horiz-adv-x="260" />
+<glyph unicode=" " horiz-adv-x="72" />
+<glyph unicode=" " horiz-adv-x="260" />
+<glyph unicode=" " horiz-adv-x="325" />
+<glyph unicode="€" d="M744 1198q242 0 354 -189q60 -104 66 -209h-181q0 45 -17.5 82.5t-43.5 61.5t-58 40.5t-60.5 24t-51.5 7.5q-19 0 -40.5 -5.5t-49.5 -20.5t-53 -38t-49 -62.5t-39 -89.5h379l-100 -100h-300q-6 -50 -6 -100h406l-100 -100h-300q9 -74 33 -132t52.5 -91t61.5 -54.5t59 -29 t47 -7.5q22 0 50.5 7.5t60.5 24.5t58 41t43.5 61t17.5 80h174q-30 -171 -128 -278q-107 -117 -274 -117q-206 0 -324 158q-36 48 -69 133t-45 204h-217l100 100h112q1 47 6 100h-218l100 100h134q20 87 51 153.5t62 103.5q117 141 297 141z" />
+<glyph unicode="₽" d="M428 1200h350q67 0 120 -13t86 -31t57 -49.5t35 -56.5t17 -64.5t6.5 -60.5t0.5 -57v-16.5v-16.5q0 -36 -0.5 -57t-6.5 -61t-17 -65t-35 -57t-57 -50.5t-86 -31.5t-120 -13h-178l-2 -100h288q10 0 13 -6t-3 -14l-120 -160q-6 -8 -18 -14t-22 -6h-138v-175q0 -11 -5.5 -18 t-15.5 -7h-149q-10 0 -17.5 7.5t-7.5 17.5v175h-267q-10 0 -13 6t3 14l120 160q6 8 18 14t22 6h117v100h-267q-10 0 -13 6t3 14l120 160q6 8 18 14t22 6h117v475q0 10 7.5 17.5t17.5 7.5zM600 1000v-300h203q64 0 86.5 33t22.5 119q0 84 -22.5 116t-86.5 32h-203z" />
+<glyph unicode="−" d="M250 700h800q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="⌛" d="M1000 1200v-150q0 -21 -14.5 -35.5t-35.5 -14.5h-50v-100q0 -91 -49.5 -165.5t-130.5 -109.5q81 -35 130.5 -109.5t49.5 -165.5v-150h50q21 0 35.5 -14.5t14.5 -35.5v-150h-800v150q0 21 14.5 35.5t35.5 14.5h50v150q0 91 49.5 165.5t130.5 109.5q-81 35 -130.5 109.5 t-49.5 165.5v100h-50q-21 0 -35.5 14.5t-14.5 35.5v150h800zM400 1000v-100q0 -60 32.5 -109.5t87.5 -73.5q28 -12 44 -37t16 -55t-16 -55t-44 -37q-55 -24 -87.5 -73.5t-32.5 -109.5v-150h400v150q0 60 -32.5 109.5t-87.5 73.5q-28 12 -44 37t-16 55t16 55t44 37 q55 24 87.5 73.5t32.5 109.5v100h-400z" />
+<glyph unicode="◼" horiz-adv-x="500" d="M0 0z" />
+<glyph unicode="☁" d="M503 1089q110 0 200.5 -59.5t134.5 -156.5q44 14 90 14q120 0 205 -86.5t85 -206.5q0 -121 -85 -207.5t-205 -86.5h-750q-79 0 -135.5 57t-56.5 137q0 69 42.5 122.5t108.5 67.5q-2 12 -2 37q0 153 108 260.5t260 107.5z" />
+<glyph unicode="⛺" d="M774 1193.5q16 -9.5 20.5 -27t-5.5 -33.5l-136 -187l467 -746h30q20 0 35 -18.5t15 -39.5v-42h-1200v42q0 21 15 39.5t35 18.5h30l468 746l-135 183q-10 16 -5.5 34t20.5 28t34 5.5t28 -20.5l111 -148l112 150q9 16 27 20.5t34 -5zM600 200h377l-182 112l-195 534v-646z " />
+<glyph unicode="✉" d="M25 1100h1150q10 0 12.5 -5t-5.5 -13l-564 -567q-8 -8 -18 -8t-18 8l-564 567q-8 8 -5.5 13t12.5 5zM18 882l264 -264q8 -8 8 -18t-8 -18l-264 -264q-8 -8 -13 -5.5t-5 12.5v550q0 10 5 12.5t13 -5.5zM918 618l264 264q8 8 13 5.5t5 -12.5v-550q0 -10 -5 -12.5t-13 5.5 l-264 264q-8 8 -8 18t8 18zM818 482l364 -364q8 -8 5.5 -13t-12.5 -5h-1150q-10 0 -12.5 5t5.5 13l364 364q8 8 18 8t18 -8l164 -164q8 -8 18 -8t18 8l164 164q8 8 18 8t18 -8z" />
+<glyph unicode="✏" d="M1011 1210q19 0 33 -13l153 -153q13 -14 13 -33t-13 -33l-99 -92l-214 214l95 96q13 14 32 14zM1013 800l-615 -614l-214 214l614 614zM317 96l-333 -112l110 335z" />
+<glyph unicode="" d="M700 650v-550h250q21 0 35.5 -14.5t14.5 -35.5v-50h-800v50q0 21 14.5 35.5t35.5 14.5h250v550l-500 550h1200z" />
+<glyph unicode="" d="M368 1017l645 163q39 15 63 0t24 -49v-831q0 -55 -41.5 -95.5t-111.5 -63.5q-79 -25 -147 -4.5t-86 75t25.5 111.5t122.5 82q72 24 138 8v521l-600 -155v-606q0 -42 -44 -90t-109 -69q-79 -26 -147 -5.5t-86 75.5t25.5 111.5t122.5 82.5q72 24 138 7v639q0 38 14.5 59 t53.5 34z" />
+<glyph unicode="" d="M500 1191q100 0 191 -39t156.5 -104.5t104.5 -156.5t39 -191l-1 -2l1 -5q0 -141 -78 -262l275 -274q23 -26 22.5 -44.5t-22.5 -42.5l-59 -58q-26 -20 -46.5 -20t-39.5 20l-275 274q-119 -77 -261 -77l-5 1l-2 -1q-100 0 -191 39t-156.5 104.5t-104.5 156.5t-39 191 t39 191t104.5 156.5t156.5 104.5t191 39zM500 1022q-88 0 -162 -43t-117 -117t-43 -162t43 -162t117 -117t162 -43t162 43t117 117t43 162t-43 162t-117 117t-162 43z" />
+<glyph unicode="" d="M649 949q48 68 109.5 104t121.5 38.5t118.5 -20t102.5 -64t71 -100.5t27 -123q0 -57 -33.5 -117.5t-94 -124.5t-126.5 -127.5t-150 -152.5t-146 -174q-62 85 -145.5 174t-150 152.5t-126.5 127.5t-93.5 124.5t-33.5 117.5q0 64 28 123t73 100.5t104 64t119 20 t120.5 -38.5t104.5 -104z" />
+<glyph unicode="" d="M407 800l131 353q7 19 17.5 19t17.5 -19l129 -353h421q21 0 24 -8.5t-14 -20.5l-342 -249l130 -401q7 -20 -0.5 -25.5t-24.5 6.5l-343 246l-342 -247q-17 -12 -24.5 -6.5t-0.5 25.5l130 400l-347 251q-17 12 -14 20.5t23 8.5h429z" />
+<glyph unicode="" d="M407 800l131 353q7 19 17.5 19t17.5 -19l129 -353h421q21 0 24 -8.5t-14 -20.5l-342 -249l130 -401q7 -20 -0.5 -25.5t-24.5 6.5l-343 246l-342 -247q-17 -12 -24.5 -6.5t-0.5 25.5l130 400l-347 251q-17 12 -14 20.5t23 8.5h429zM477 700h-240l197 -142l-74 -226 l193 139l195 -140l-74 229l192 140h-234l-78 211z" />
+<glyph unicode="" d="M600 1200q124 0 212 -88t88 -212v-250q0 -46 -31 -98t-69 -52v-75q0 -10 6 -21.5t15 -17.5l358 -230q9 -5 15 -16.5t6 -21.5v-93q0 -10 -7.5 -17.5t-17.5 -7.5h-1150q-10 0 -17.5 7.5t-7.5 17.5v93q0 10 6 21.5t15 16.5l358 230q9 6 15 17.5t6 21.5v75q-38 0 -69 52 t-31 98v250q0 124 88 212t212 88z" />
+<glyph unicode="" d="M25 1100h1150q10 0 17.5 -7.5t7.5 -17.5v-1050q0 -10 -7.5 -17.5t-17.5 -7.5h-1150q-10 0 -17.5 7.5t-7.5 17.5v1050q0 10 7.5 17.5t17.5 7.5zM100 1000v-100h100v100h-100zM875 1000h-550q-10 0 -17.5 -7.5t-7.5 -17.5v-350q0 -10 7.5 -17.5t17.5 -7.5h550 q10 0 17.5 7.5t7.5 17.5v350q0 10 -7.5 17.5t-17.5 7.5zM1000 1000v-100h100v100h-100zM100 800v-100h100v100h-100zM1000 800v-100h100v100h-100zM100 600v-100h100v100h-100zM1000 600v-100h100v100h-100zM875 500h-550q-10 0 -17.5 -7.5t-7.5 -17.5v-350q0 -10 7.5 -17.5 t17.5 -7.5h550q10 0 17.5 7.5t7.5 17.5v350q0 10 -7.5 17.5t-17.5 7.5zM100 400v-100h100v100h-100zM1000 400v-100h100v100h-100zM100 200v-100h100v100h-100zM1000 200v-100h100v100h-100z" />
+<glyph unicode="" d="M50 1100h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5zM650 1100h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v400 q0 21 14.5 35.5t35.5 14.5zM50 500h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5zM650 500h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400 q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M50 1100h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM450 1100h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200 q0 21 14.5 35.5t35.5 14.5zM850 1100h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM50 700h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200 q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM450 700h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM850 700h200q21 0 35.5 -14.5t14.5 -35.5v-200 q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM50 300h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM450 300h200 q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM850 300h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5 t35.5 14.5z" />
+<glyph unicode="" d="M50 1100h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM450 1100h700q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-700q-21 0 -35.5 14.5t-14.5 35.5v200 q0 21 14.5 35.5t35.5 14.5zM50 700h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM450 700h700q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-700 q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM50 300h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5zM450 300h700q21 0 35.5 -14.5t14.5 -35.5v-200 q0 -21 -14.5 -35.5t-35.5 -14.5h-700q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M465 477l571 571q8 8 18 8t17 -8l177 -177q8 -7 8 -17t-8 -18l-783 -784q-7 -8 -17.5 -8t-17.5 8l-384 384q-8 8 -8 18t8 17l177 177q7 8 17 8t18 -8l171 -171q7 -7 18 -7t18 7z" />
+<glyph unicode="" d="M904 1083l178 -179q8 -8 8 -18.5t-8 -17.5l-267 -268l267 -268q8 -7 8 -17.5t-8 -18.5l-178 -178q-8 -8 -18.5 -8t-17.5 8l-268 267l-268 -267q-7 -8 -17.5 -8t-18.5 8l-178 178q-8 8 -8 18.5t8 17.5l267 268l-267 268q-8 7 -8 17.5t8 18.5l178 178q8 8 18.5 8t17.5 -8 l268 -267l268 268q7 7 17.5 7t18.5 -7z" />
+<glyph unicode="" d="M507 1177q98 0 187.5 -38.5t154.5 -103.5t103.5 -154.5t38.5 -187.5q0 -141 -78 -262l300 -299q8 -8 8 -18.5t-8 -18.5l-109 -108q-7 -8 -17.5 -8t-18.5 8l-300 299q-119 -77 -261 -77q-98 0 -188 38.5t-154.5 103t-103 154.5t-38.5 188t38.5 187.5t103 154.5 t154.5 103.5t188 38.5zM506.5 1023q-89.5 0 -165.5 -44t-120 -120.5t-44 -166t44 -165.5t120 -120t165.5 -44t166 44t120.5 120t44 165.5t-44 166t-120.5 120.5t-166 44zM425 900h150q10 0 17.5 -7.5t7.5 -17.5v-75h75q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5 t-17.5 -7.5h-75v-75q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v75h-75q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5h75v75q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M507 1177q98 0 187.5 -38.5t154.5 -103.5t103.5 -154.5t38.5 -187.5q0 -141 -78 -262l300 -299q8 -8 8 -18.5t-8 -18.5l-109 -108q-7 -8 -17.5 -8t-18.5 8l-300 299q-119 -77 -261 -77q-98 0 -188 38.5t-154.5 103t-103 154.5t-38.5 188t38.5 187.5t103 154.5 t154.5 103.5t188 38.5zM506.5 1023q-89.5 0 -165.5 -44t-120 -120.5t-44 -166t44 -165.5t120 -120t165.5 -44t166 44t120.5 120t44 165.5t-44 166t-120.5 120.5t-166 44zM325 800h350q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-350q-10 0 -17.5 7.5 t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M550 1200h100q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5zM800 975v166q167 -62 272 -209.5t105 -331.5q0 -117 -45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5 t-184.5 123t-123 184.5t-45.5 224q0 184 105 331.5t272 209.5v-166q-103 -55 -165 -155t-62 -220q0 -116 57 -214.5t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5q0 120 -62 220t-165 155z" />
+<glyph unicode="" d="M1025 1200h150q10 0 17.5 -7.5t7.5 -17.5v-1150q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v1150q0 10 7.5 17.5t17.5 7.5zM725 800h150q10 0 17.5 -7.5t7.5 -17.5v-750q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v750 q0 10 7.5 17.5t17.5 7.5zM425 500h150q10 0 17.5 -7.5t7.5 -17.5v-450q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v450q0 10 7.5 17.5t17.5 7.5zM125 300h150q10 0 17.5 -7.5t7.5 -17.5v-250q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5 v250q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M600 1174q33 0 74 -5l38 -152l5 -1q49 -14 94 -39l5 -2l134 80q61 -48 104 -105l-80 -134l3 -5q25 -44 39 -93l1 -6l152 -38q5 -43 5 -73q0 -34 -5 -74l-152 -38l-1 -6q-15 -49 -39 -93l-3 -5l80 -134q-48 -61 -104 -105l-134 81l-5 -3q-44 -25 -94 -39l-5 -2l-38 -151 q-43 -5 -74 -5q-33 0 -74 5l-38 151l-5 2q-49 14 -94 39l-5 3l-134 -81q-60 48 -104 105l80 134l-3 5q-25 45 -38 93l-2 6l-151 38q-6 42 -6 74q0 33 6 73l151 38l2 6q13 48 38 93l3 5l-80 134q47 61 105 105l133 -80l5 2q45 25 94 39l5 1l38 152q43 5 74 5zM600 815 q-89 0 -152 -63t-63 -151.5t63 -151.5t152 -63t152 63t63 151.5t-63 151.5t-152 63z" />
+<glyph unicode="" d="M500 1300h300q41 0 70.5 -29.5t29.5 -70.5v-100h275q10 0 17.5 -7.5t7.5 -17.5v-75h-1100v75q0 10 7.5 17.5t17.5 7.5h275v100q0 41 29.5 70.5t70.5 29.5zM500 1200v-100h300v100h-300zM1100 900v-800q0 -41 -29.5 -70.5t-70.5 -29.5h-700q-41 0 -70.5 29.5t-29.5 70.5 v800h900zM300 800v-700h100v700h-100zM500 800v-700h100v700h-100zM700 800v-700h100v700h-100zM900 800v-700h100v700h-100z" />
+<glyph unicode="" d="M18 618l620 608q8 7 18.5 7t17.5 -7l608 -608q8 -8 5.5 -13t-12.5 -5h-175v-575q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v375h-300v-375q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v575h-175q-10 0 -12.5 5t5.5 13z" />
+<glyph unicode="" d="M600 1200v-400q0 -41 29.5 -70.5t70.5 -29.5h300v-650q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5v1100q0 21 14.5 35.5t35.5 14.5h450zM1000 800h-250q-21 0 -35.5 14.5t-14.5 35.5v250z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 1027q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5 t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5t-57 214.5t-155.5 155.5t-214.5 57zM525 900h50q10 0 17.5 -7.5t7.5 -17.5v-275h175q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v350q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M1300 0h-538l-41 400h-242l-41 -400h-538l431 1200h209l-21 -300h162l-20 300h208zM515 800l-27 -300h224l-27 300h-170z" />
+<glyph unicode="" d="M550 1200h200q21 0 35.5 -14.5t14.5 -35.5v-450h191q20 0 25.5 -11.5t-7.5 -27.5l-327 -400q-13 -16 -32 -16t-32 16l-327 400q-13 16 -7.5 27.5t25.5 11.5h191v450q0 21 14.5 35.5t35.5 14.5zM1125 400h50q10 0 17.5 -7.5t7.5 -17.5v-350q0 -10 -7.5 -17.5t-17.5 -7.5 h-1050q-10 0 -17.5 7.5t-7.5 17.5v350q0 10 7.5 17.5t17.5 7.5h50q10 0 17.5 -7.5t7.5 -17.5v-175h900v175q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 1027q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5 t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5t-57 214.5t-155.5 155.5t-214.5 57zM525 900h150q10 0 17.5 -7.5t7.5 -17.5v-275h137q21 0 26 -11.5t-8 -27.5l-223 -275q-13 -16 -32 -16t-32 16l-223 275q-13 16 -8 27.5t26 11.5h137v275q0 10 7.5 17.5t17.5 7.5z " />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 1027q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5 t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5t-57 214.5t-155.5 155.5t-214.5 57zM632 914l223 -275q13 -16 8 -27.5t-26 -11.5h-137v-275q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v275h-137q-21 0 -26 11.5t8 27.5l223 275q13 16 32 16 t32 -16z" />
+<glyph unicode="" d="M225 1200h750q10 0 19.5 -7t12.5 -17l186 -652q7 -24 7 -49v-425q0 -12 -4 -27t-9 -17q-12 -6 -37 -6h-1100q-12 0 -27 4t-17 8q-6 13 -6 38l1 425q0 25 7 49l185 652q3 10 12.5 17t19.5 7zM878 1000h-556q-10 0 -19 -7t-11 -18l-87 -450q-2 -11 4 -18t16 -7h150 q10 0 19.5 -7t11.5 -17l38 -152q2 -10 11.5 -17t19.5 -7h250q10 0 19.5 7t11.5 17l38 152q2 10 11.5 17t19.5 7h150q10 0 16 7t4 18l-87 450q-2 11 -11 18t-19 7z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 1027q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5 t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5t-57 214.5t-155.5 155.5t-214.5 57zM540 820l253 -190q17 -12 17 -30t-17 -30l-253 -190q-16 -12 -28 -6.5t-12 26.5v400q0 21 12 26.5t28 -6.5z" />
+<glyph unicode="" d="M947 1060l135 135q7 7 12.5 5t5.5 -13v-362q0 -10 -7.5 -17.5t-17.5 -7.5h-362q-11 0 -13 5.5t5 12.5l133 133q-109 76 -238 76q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5h150q0 -117 -45.5 -224 t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5q192 0 347 -117z" />
+<glyph unicode="" d="M947 1060l135 135q7 7 12.5 5t5.5 -13v-361q0 -11 -7.5 -18.5t-18.5 -7.5h-361q-11 0 -13 5.5t5 12.5l134 134q-110 75 -239 75q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5h-150q0 117 45.5 224t123 184.5t184.5 123t224 45.5q192 0 347 -117zM1027 600h150 q0 -117 -45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5q-192 0 -348 118l-134 -134q-7 -8 -12.5 -5.5t-5.5 12.5v360q0 11 7.5 18.5t18.5 7.5h360q10 0 12.5 -5.5t-5.5 -12.5l-133 -133q110 -76 240 -76q116 0 214.5 57t155.5 155.5t57 214.5z" />
+<glyph unicode="" d="M125 1200h1050q10 0 17.5 -7.5t7.5 -17.5v-1150q0 -10 -7.5 -17.5t-17.5 -7.5h-1050q-10 0 -17.5 7.5t-7.5 17.5v1150q0 10 7.5 17.5t17.5 7.5zM1075 1000h-850q-10 0 -17.5 -7.5t-7.5 -17.5v-850q0 -10 7.5 -17.5t17.5 -7.5h850q10 0 17.5 7.5t7.5 17.5v850 q0 10 -7.5 17.5t-17.5 7.5zM325 900h50q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-50q-10 0 -17.5 7.5t-7.5 17.5v50q0 10 7.5 17.5t17.5 7.5zM525 900h450q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-450q-10 0 -17.5 7.5t-7.5 17.5v50 q0 10 7.5 17.5t17.5 7.5zM325 700h50q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-50q-10 0 -17.5 7.5t-7.5 17.5v50q0 10 7.5 17.5t17.5 7.5zM525 700h450q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-450q-10 0 -17.5 7.5t-7.5 17.5v50 q0 10 7.5 17.5t17.5 7.5zM325 500h50q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-50q-10 0 -17.5 7.5t-7.5 17.5v50q0 10 7.5 17.5t17.5 7.5zM525 500h450q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-450q-10 0 -17.5 7.5t-7.5 17.5v50 q0 10 7.5 17.5t17.5 7.5zM325 300h50q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-50q-10 0 -17.5 7.5t-7.5 17.5v50q0 10 7.5 17.5t17.5 7.5zM525 300h450q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-450q-10 0 -17.5 7.5t-7.5 17.5v50 q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M900 800v200q0 83 -58.5 141.5t-141.5 58.5h-300q-82 0 -141 -59t-59 -141v-200h-100q-41 0 -70.5 -29.5t-29.5 -70.5v-600q0 -41 29.5 -70.5t70.5 -29.5h900q41 0 70.5 29.5t29.5 70.5v600q0 41 -29.5 70.5t-70.5 29.5h-100zM400 800v150q0 21 15 35.5t35 14.5h200 q20 0 35 -14.5t15 -35.5v-150h-300z" />
+<glyph unicode="" d="M125 1100h50q10 0 17.5 -7.5t7.5 -17.5v-1075h-100v1075q0 10 7.5 17.5t17.5 7.5zM1075 1052q4 0 9 -2q16 -6 16 -23v-421q0 -6 -3 -12q-33 -59 -66.5 -99t-65.5 -58t-56.5 -24.5t-52.5 -6.5q-26 0 -57.5 6.5t-52.5 13.5t-60 21q-41 15 -63 22.5t-57.5 15t-65.5 7.5 q-85 0 -160 -57q-7 -5 -15 -5q-6 0 -11 3q-14 7 -14 22v438q22 55 82 98.5t119 46.5q23 2 43 0.5t43 -7t32.5 -8.5t38 -13t32.5 -11q41 -14 63.5 -21t57 -14t63.5 -7q103 0 183 87q7 8 18 8z" />
+<glyph unicode="" d="M600 1175q116 0 227 -49.5t192.5 -131t131 -192.5t49.5 -227v-300q0 -10 -7.5 -17.5t-17.5 -7.5h-50q-10 0 -17.5 7.5t-7.5 17.5v300q0 127 -70.5 231.5t-184.5 161.5t-245 57t-245 -57t-184.5 -161.5t-70.5 -231.5v-300q0 -10 -7.5 -17.5t-17.5 -7.5h-50 q-10 0 -17.5 7.5t-7.5 17.5v300q0 116 49.5 227t131 192.5t192.5 131t227 49.5zM220 500h160q8 0 14 -6t6 -14v-460q0 -8 -6 -14t-14 -6h-160q-8 0 -14 6t-6 14v460q0 8 6 14t14 6zM820 500h160q8 0 14 -6t6 -14v-460q0 -8 -6 -14t-14 -6h-160q-8 0 -14 6t-6 14v460 q0 8 6 14t14 6z" />
+<glyph unicode="" d="M321 814l258 172q9 6 15 2.5t6 -13.5v-750q0 -10 -6 -13.5t-15 2.5l-258 172q-21 14 -46 14h-250q-10 0 -17.5 7.5t-7.5 17.5v350q0 10 7.5 17.5t17.5 7.5h250q25 0 46 14zM900 668l120 120q7 7 17 7t17 -7l34 -34q7 -7 7 -17t-7 -17l-120 -120l120 -120q7 -7 7 -17 t-7 -17l-34 -34q-7 -7 -17 -7t-17 7l-120 119l-120 -119q-7 -7 -17 -7t-17 7l-34 34q-7 7 -7 17t7 17l119 120l-119 120q-7 7 -7 17t7 17l34 34q7 8 17 8t17 -8z" />
+<glyph unicode="" d="M321 814l258 172q9 6 15 2.5t6 -13.5v-750q0 -10 -6 -13.5t-15 2.5l-258 172q-21 14 -46 14h-250q-10 0 -17.5 7.5t-7.5 17.5v350q0 10 7.5 17.5t17.5 7.5h250q25 0 46 14zM766 900h4q10 -1 16 -10q96 -129 96 -290q0 -154 -90 -281q-6 -9 -17 -10l-3 -1q-9 0 -16 6 l-29 23q-7 7 -8.5 16.5t4.5 17.5q72 103 72 229q0 132 -78 238q-6 8 -4.5 18t9.5 17l29 22q7 5 15 5z" />
+<glyph unicode="" d="M967 1004h3q11 -1 17 -10q135 -179 135 -396q0 -105 -34 -206.5t-98 -185.5q-7 -9 -17 -10h-3q-9 0 -16 6l-42 34q-8 6 -9 16t5 18q111 150 111 328q0 90 -29.5 176t-84.5 157q-6 9 -5 19t10 16l42 33q7 5 15 5zM321 814l258 172q9 6 15 2.5t6 -13.5v-750q0 -10 -6 -13.5 t-15 2.5l-258 172q-21 14 -46 14h-250q-10 0 -17.5 7.5t-7.5 17.5v350q0 10 7.5 17.5t17.5 7.5h250q25 0 46 14zM766 900h4q10 -1 16 -10q96 -129 96 -290q0 -154 -90 -281q-6 -9 -17 -10l-3 -1q-9 0 -16 6l-29 23q-7 7 -8.5 16.5t4.5 17.5q72 103 72 229q0 132 -78 238 q-6 8 -4.5 18.5t9.5 16.5l29 22q7 5 15 5z" />
+<glyph unicode="" d="M500 900h100v-100h-100v-100h-400v-100h-100v600h500v-300zM1200 700h-200v-100h200v-200h-300v300h-200v300h-100v200h600v-500zM100 1100v-300h300v300h-300zM800 1100v-300h300v300h-300zM300 900h-100v100h100v-100zM1000 900h-100v100h100v-100zM300 500h200v-500 h-500v500h200v100h100v-100zM800 300h200v-100h-100v-100h-200v100h-100v100h100v200h-200v100h300v-300zM100 400v-300h300v300h-300zM300 200h-100v100h100v-100zM1200 200h-100v100h100v-100zM700 0h-100v100h100v-100zM1200 0h-300v100h300v-100z" />
+<glyph unicode="" d="M100 200h-100v1000h100v-1000zM300 200h-100v1000h100v-1000zM700 200h-200v1000h200v-1000zM900 200h-100v1000h100v-1000zM1200 200h-200v1000h200v-1000zM400 0h-300v100h300v-100zM600 0h-100v91h100v-91zM800 0h-100v91h100v-91zM1100 0h-200v91h200v-91z" />
+<glyph unicode="" d="M500 1200l682 -682q8 -8 8 -18t-8 -18l-464 -464q-8 -8 -18 -8t-18 8l-682 682l1 475q0 10 7.5 17.5t17.5 7.5h474zM319.5 1024.5q-29.5 29.5 -71 29.5t-71 -29.5t-29.5 -71.5t29.5 -71.5t71 -29.5t71 29.5t29.5 71.5t-29.5 71.5z" />
+<glyph unicode="" d="M500 1200l682 -682q8 -8 8 -18t-8 -18l-464 -464q-8 -8 -18 -8t-18 8l-682 682l1 475q0 10 7.5 17.5t17.5 7.5h474zM800 1200l682 -682q8 -8 8 -18t-8 -18l-464 -464q-8 -8 -18 -8t-18 8l-56 56l424 426l-700 700h150zM319.5 1024.5q-29.5 29.5 -71 29.5t-71 -29.5 t-29.5 -71.5t29.5 -71.5t71 -29.5t71 29.5t29.5 71.5t-29.5 71.5z" />
+<glyph unicode="" d="M300 1200h825q75 0 75 -75v-900q0 -25 -18 -43l-64 -64q-8 -8 -13 -5.5t-5 12.5v950q0 10 -7.5 17.5t-17.5 7.5h-700q-25 0 -43 -18l-64 -64q-8 -8 -5.5 -13t12.5 -5h700q10 0 17.5 -7.5t7.5 -17.5v-950q0 -10 -7.5 -17.5t-17.5 -7.5h-850q-10 0 -17.5 7.5t-7.5 17.5v975 q0 25 18 43l139 139q18 18 43 18z" />
+<glyph unicode="" d="M250 1200h800q21 0 35.5 -14.5t14.5 -35.5v-1150l-450 444l-450 -445v1151q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M822 1200h-444q-11 0 -19 -7.5t-9 -17.5l-78 -301q-7 -24 7 -45l57 -108q6 -9 17.5 -15t21.5 -6h450q10 0 21.5 6t17.5 15l62 108q14 21 7 45l-83 301q-1 10 -9 17.5t-19 7.5zM1175 800h-150q-10 0 -21 -6.5t-15 -15.5l-78 -156q-4 -9 -15 -15.5t-21 -6.5h-550 q-10 0 -21 6.5t-15 15.5l-78 156q-4 9 -15 15.5t-21 6.5h-150q-10 0 -17.5 -7.5t-7.5 -17.5v-650q0 -10 7.5 -17.5t17.5 -7.5h150q10 0 17.5 7.5t7.5 17.5v150q0 10 7.5 17.5t17.5 7.5h750q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 7.5 -17.5t17.5 -7.5h150q10 0 17.5 7.5 t7.5 17.5v650q0 10 -7.5 17.5t-17.5 7.5zM850 200h-500q-10 0 -19.5 -7t-11.5 -17l-38 -152q-2 -10 3.5 -17t15.5 -7h600q10 0 15.5 7t3.5 17l-38 152q-2 10 -11.5 17t-19.5 7z" />
+<glyph unicode="" d="M500 1100h200q56 0 102.5 -20.5t72.5 -50t44 -59t25 -50.5l6 -20h150q41 0 70.5 -29.5t29.5 -70.5v-600q0 -41 -29.5 -70.5t-70.5 -29.5h-1000q-41 0 -70.5 29.5t-29.5 70.5v600q0 41 29.5 70.5t70.5 29.5h150q2 8 6.5 21.5t24 48t45 61t72 48t102.5 21.5zM900 800v-100 h100v100h-100zM600 730q-95 0 -162.5 -67.5t-67.5 -162.5t67.5 -162.5t162.5 -67.5t162.5 67.5t67.5 162.5t-67.5 162.5t-162.5 67.5zM600 603q43 0 73 -30t30 -73t-30 -73t-73 -30t-73 30t-30 73t30 73t73 30z" />
+<glyph unicode="" d="M681 1199l385 -998q20 -50 60 -92q18 -19 36.5 -29.5t27.5 -11.5l10 -2v-66h-417v66q53 0 75 43.5t5 88.5l-82 222h-391q-58 -145 -92 -234q-11 -34 -6.5 -57t25.5 -37t46 -20t55 -6v-66h-365v66q56 24 84 52q12 12 25 30.5t20 31.5l7 13l399 1006h93zM416 521h340 l-162 457z" />
+<glyph unicode="" d="M753 641q5 -1 14.5 -4.5t36 -15.5t50.5 -26.5t53.5 -40t50.5 -54.5t35.5 -70t14.5 -87q0 -67 -27.5 -125.5t-71.5 -97.5t-98.5 -66.5t-108.5 -40.5t-102 -13h-500v89q41 7 70.5 32.5t29.5 65.5v827q0 24 -0.5 34t-3.5 24t-8.5 19.5t-17 13.5t-28 12.5t-42.5 11.5v71 l471 -1q57 0 115.5 -20.5t108 -57t80.5 -94t31 -124.5q0 -51 -15.5 -96.5t-38 -74.5t-45 -50.5t-38.5 -30.5zM400 700h139q78 0 130.5 48.5t52.5 122.5q0 41 -8.5 70.5t-29.5 55.5t-62.5 39.5t-103.5 13.5h-118v-350zM400 200h216q80 0 121 50.5t41 130.5q0 90 -62.5 154.5 t-156.5 64.5h-159v-400z" />
+<glyph unicode="" d="M877 1200l2 -57q-83 -19 -116 -45.5t-40 -66.5l-132 -839q-9 -49 13 -69t96 -26v-97h-500v97q186 16 200 98l173 832q3 17 3 30t-1.5 22.5t-9 17.5t-13.5 12.5t-21.5 10t-26 8.5t-33.5 10q-13 3 -19 5v57h425z" />
+<glyph unicode="" d="M1300 900h-50q0 21 -4 37t-9.5 26.5t-18 17.5t-22 11t-28.5 5.5t-31 2t-37 0.5h-200v-850q0 -22 25 -34.5t50 -13.5l25 -2v-100h-400v100q4 0 11 0.5t24 3t30 7t24 15t11 24.5v850h-200q-25 0 -37 -0.5t-31 -2t-28.5 -5.5t-22 -11t-18 -17.5t-9.5 -26.5t-4 -37h-50v300 h1000v-300zM175 1000h-75v-800h75l-125 -167l-125 167h75v800h-75l125 167z" />
+<glyph unicode="" d="M1100 900h-50q0 21 -4 37t-9.5 26.5t-18 17.5t-22 11t-28.5 5.5t-31 2t-37 0.5h-200v-650q0 -22 25 -34.5t50 -13.5l25 -2v-100h-400v100q4 0 11 0.5t24 3t30 7t24 15t11 24.5v650h-200q-25 0 -37 -0.5t-31 -2t-28.5 -5.5t-22 -11t-18 -17.5t-9.5 -26.5t-4 -37h-50v300 h1000v-300zM1167 50l-167 -125v75h-800v-75l-167 125l167 125v-75h800v75z" />
+<glyph unicode="" d="M50 1100h600q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-600q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 800h1000q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1000q-21 0 -35.5 14.5t-14.5 35.5v100 q0 21 14.5 35.5t35.5 14.5zM50 500h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 200h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100 q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M250 1100h700q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-700q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 800h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5v100 q0 21 14.5 35.5t35.5 14.5zM250 500h700q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-700q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 200h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100 q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M500 950v100q0 21 14.5 35.5t35.5 14.5h600q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-600q-21 0 -35.5 14.5t-14.5 35.5zM100 650v100q0 21 14.5 35.5t35.5 14.5h1000q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1000 q-21 0 -35.5 14.5t-14.5 35.5zM300 350v100q0 21 14.5 35.5t35.5 14.5h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5zM0 50v100q0 21 14.5 35.5t35.5 14.5h1100q21 0 35.5 -14.5t14.5 -35.5v-100 q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5z" />
+<glyph unicode="" d="M50 1100h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 800h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5v100 q0 21 14.5 35.5t35.5 14.5zM50 500h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 200h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100 q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M50 1100h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM350 1100h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5v100 q0 21 14.5 35.5t35.5 14.5zM50 800h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM350 800h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-800 q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 500h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM350 500h800q21 0 35.5 -14.5t14.5 -35.5v-100 q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 200h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM350 200h800 q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M400 0h-100v1100h100v-1100zM550 1100h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM550 800h500q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-500 q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM267 550l-167 -125v75h-200v100h200v75zM550 500h300q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-300q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM550 200h600 q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-600q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M50 1100h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM900 0h-100v1100h100v-1100zM50 800h500q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-500 q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM1100 600h200v-100h-200v-75l-167 125l167 125v-75zM50 500h300q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-300q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5zM50 200h600 q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-600q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M75 1000h750q31 0 53 -22t22 -53v-650q0 -31 -22 -53t-53 -22h-750q-31 0 -53 22t-22 53v650q0 31 22 53t53 22zM1200 300l-300 300l300 300v-600z" />
+<glyph unicode="" d="M44 1100h1112q18 0 31 -13t13 -31v-1012q0 -18 -13 -31t-31 -13h-1112q-18 0 -31 13t-13 31v1012q0 18 13 31t31 13zM100 1000v-737l247 182l298 -131l-74 156l293 318l236 -288v500h-1000zM342 884q56 0 95 -39t39 -94.5t-39 -95t-95 -39.5t-95 39.5t-39 95t39 94.5 t95 39z" />
+<glyph unicode="" d="M648 1169q117 0 216 -60t156.5 -161t57.5 -218q0 -115 -70 -258q-69 -109 -158 -225.5t-143 -179.5l-54 -62q-9 8 -25.5 24.5t-63.5 67.5t-91 103t-98.5 128t-95.5 148q-60 132 -60 249q0 88 34 169.5t91.5 142t137 96.5t166.5 36zM652.5 974q-91.5 0 -156.5 -65 t-65 -157t65 -156.5t156.5 -64.5t156.5 64.5t65 156.5t-65 157t-156.5 65z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 173v854q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5 t155.5 -155.5t214.5 -57z" />
+<glyph unicode="" d="M554 1295q21 -72 57.5 -143.5t76 -130t83 -118t82.5 -117t70 -116t49.5 -126t18.5 -136.5q0 -71 -25.5 -135t-68.5 -111t-99 -82t-118.5 -54t-125.5 -23q-84 5 -161.5 34t-139.5 78.5t-99 125t-37 164.5q0 69 18 136.5t49.5 126.5t69.5 116.5t81.5 117.5t83.5 119 t76.5 131t58.5 143zM344 710q-23 -33 -43.5 -70.5t-40.5 -102.5t-17 -123q1 -37 14.5 -69.5t30 -52t41 -37t38.5 -24.5t33 -15q21 -7 32 -1t13 22l6 34q2 10 -2.5 22t-13.5 19q-5 4 -14 12t-29.5 40.5t-32.5 73.5q-26 89 6 271q2 11 -6 11q-8 1 -15 -10z" />
+<glyph unicode="" d="M1000 1013l108 115q2 1 5 2t13 2t20.5 -1t25 -9.5t28.5 -21.5q22 -22 27 -43t0 -32l-6 -10l-108 -115zM350 1100h400q50 0 105 -13l-187 -187h-368q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v182l200 200v-332 q0 -165 -93.5 -257.5t-256.5 -92.5h-400q-165 0 -257.5 92.5t-92.5 257.5v400q0 165 92.5 257.5t257.5 92.5zM1009 803l-362 -362l-161 -50l55 170l355 355z" />
+<glyph unicode="" d="M350 1100h361q-164 -146 -216 -200h-195q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5l200 153v-103q0 -165 -92.5 -257.5t-257.5 -92.5h-400q-165 0 -257.5 92.5t-92.5 257.5v400q0 165 92.5 257.5t257.5 92.5z M824 1073l339 -301q8 -7 8 -17.5t-8 -17.5l-340 -306q-7 -6 -12.5 -4t-6.5 11v203q-26 1 -54.5 0t-78.5 -7.5t-92 -17.5t-86 -35t-70 -57q10 59 33 108t51.5 81.5t65 58.5t68.5 40.5t67 24.5t56 13.5t40 4.5v210q1 10 6.5 12.5t13.5 -4.5z" />
+<glyph unicode="" d="M350 1100h350q60 0 127 -23l-178 -177h-349q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v69l200 200v-219q0 -165 -92.5 -257.5t-257.5 -92.5h-400q-165 0 -257.5 92.5t-92.5 257.5v400q0 165 92.5 257.5t257.5 92.5z M643 639l395 395q7 7 17.5 7t17.5 -7l101 -101q7 -7 7 -17.5t-7 -17.5l-531 -532q-7 -7 -17.5 -7t-17.5 7l-248 248q-7 7 -7 17.5t7 17.5l101 101q7 7 17.5 7t17.5 -7l111 -111q8 -7 18 -7t18 7z" />
+<glyph unicode="" d="M318 918l264 264q8 8 18 8t18 -8l260 -264q7 -8 4.5 -13t-12.5 -5h-170v-200h200v173q0 10 5 12t13 -5l264 -260q8 -7 8 -17.5t-8 -17.5l-264 -265q-8 -7 -13 -5t-5 12v173h-200v-200h170q10 0 12.5 -5t-4.5 -13l-260 -264q-8 -8 -18 -8t-18 8l-264 264q-8 8 -5.5 13 t12.5 5h175v200h-200v-173q0 -10 -5 -12t-13 5l-264 265q-8 7 -8 17.5t8 17.5l264 260q8 7 13 5t5 -12v-173h200v200h-175q-10 0 -12.5 5t5.5 13z" />
+<glyph unicode="" d="M250 1100h100q21 0 35.5 -14.5t14.5 -35.5v-438l464 453q15 14 25.5 10t10.5 -25v-1000q0 -21 -10.5 -25t-25.5 10l-464 453v-438q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v1000q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M50 1100h100q21 0 35.5 -14.5t14.5 -35.5v-438l464 453q15 14 25.5 10t10.5 -25v-438l464 453q15 14 25.5 10t10.5 -25v-1000q0 -21 -10.5 -25t-25.5 10l-464 453v-438q0 -21 -10.5 -25t-25.5 10l-464 453v-438q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5 t-14.5 35.5v1000q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M1200 1050v-1000q0 -21 -10.5 -25t-25.5 10l-464 453v-438q0 -21 -10.5 -25t-25.5 10l-492 480q-15 14 -15 35t15 35l492 480q15 14 25.5 10t10.5 -25v-438l464 453q15 14 25.5 10t10.5 -25z" />
+<glyph unicode="" d="M243 1074l814 -498q18 -11 18 -26t-18 -26l-814 -498q-18 -11 -30.5 -4t-12.5 28v1000q0 21 12.5 28t30.5 -4z" />
+<glyph unicode="" d="M250 1000h200q21 0 35.5 -14.5t14.5 -35.5v-800q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v800q0 21 14.5 35.5t35.5 14.5zM650 1000h200q21 0 35.5 -14.5t14.5 -35.5v-800q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v800 q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M1100 950v-800q0 -21 -14.5 -35.5t-35.5 -14.5h-800q-21 0 -35.5 14.5t-14.5 35.5v800q0 21 14.5 35.5t35.5 14.5h800q21 0 35.5 -14.5t14.5 -35.5z" />
+<glyph unicode="" d="M500 612v438q0 21 10.5 25t25.5 -10l492 -480q15 -14 15 -35t-15 -35l-492 -480q-15 -14 -25.5 -10t-10.5 25v438l-464 -453q-15 -14 -25.5 -10t-10.5 25v1000q0 21 10.5 25t25.5 -10z" />
+<glyph unicode="" d="M1048 1102l100 1q20 0 35 -14.5t15 -35.5l5 -1000q0 -21 -14.5 -35.5t-35.5 -14.5l-100 -1q-21 0 -35.5 14.5t-14.5 35.5l-2 437l-463 -454q-14 -15 -24.5 -10.5t-10.5 25.5l-2 437l-462 -455q-15 -14 -25.5 -9.5t-10.5 24.5l-5 1000q0 21 10.5 25.5t25.5 -10.5l466 -450 l-2 438q0 20 10.5 24.5t25.5 -9.5l466 -451l-2 438q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M850 1100h100q21 0 35.5 -14.5t14.5 -35.5v-1000q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v438l-464 -453q-15 -14 -25.5 -10t-10.5 25v1000q0 21 10.5 25t25.5 -10l464 -453v438q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M686 1081l501 -540q15 -15 10.5 -26t-26.5 -11h-1042q-22 0 -26.5 11t10.5 26l501 540q15 15 36 15t36 -15zM150 400h1000q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1000q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M885 900l-352 -353l352 -353l-197 -198l-552 552l552 550z" />
+<glyph unicode="" d="M1064 547l-551 -551l-198 198l353 353l-353 353l198 198z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM650 900h-100q-21 0 -35.5 -14.5t-14.5 -35.5v-150h-150 q-21 0 -35.5 -14.5t-14.5 -35.5v-100q0 -21 14.5 -35.5t35.5 -14.5h150v-150q0 -21 14.5 -35.5t35.5 -14.5h100q21 0 35.5 14.5t14.5 35.5v150h150q21 0 35.5 14.5t14.5 35.5v100q0 21 -14.5 35.5t-35.5 14.5h-150v150q0 21 -14.5 35.5t-35.5 14.5z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM850 700h-500q-21 0 -35.5 -14.5t-14.5 -35.5v-100q0 -21 14.5 -35.5 t35.5 -14.5h500q21 0 35.5 14.5t14.5 35.5v100q0 21 -14.5 35.5t-35.5 14.5z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM741.5 913q-12.5 0 -21.5 -9l-120 -120l-120 120q-9 9 -21.5 9 t-21.5 -9l-141 -141q-9 -9 -9 -21.5t9 -21.5l120 -120l-120 -120q-9 -9 -9 -21.5t9 -21.5l141 -141q9 -9 21.5 -9t21.5 9l120 120l120 -120q9 -9 21.5 -9t21.5 9l141 141q9 9 9 21.5t-9 21.5l-120 120l120 120q9 9 9 21.5t-9 21.5l-141 141q-9 9 -21.5 9z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM546 623l-84 85q-7 7 -17.5 7t-18.5 -7l-139 -139q-7 -8 -7 -18t7 -18 l242 -241q7 -8 17.5 -8t17.5 8l375 375q7 7 7 17.5t-7 18.5l-139 139q-7 7 -17.5 7t-17.5 -7z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM588 941q-29 0 -59 -5.5t-63 -20.5t-58 -38.5t-41.5 -63t-16.5 -89.5 q0 -25 20 -25h131q30 -5 35 11q6 20 20.5 28t45.5 8q20 0 31.5 -10.5t11.5 -28.5q0 -23 -7 -34t-26 -18q-1 0 -13.5 -4t-19.5 -7.5t-20 -10.5t-22 -17t-18.5 -24t-15.5 -35t-8 -46q-1 -8 5.5 -16.5t20.5 -8.5h173q7 0 22 8t35 28t37.5 48t29.5 74t12 100q0 47 -17 83 t-42.5 57t-59.5 34.5t-64 18t-59 4.5zM675 400h-150q-10 0 -17.5 -7.5t-7.5 -17.5v-150q0 -10 7.5 -17.5t17.5 -7.5h150q10 0 17.5 7.5t7.5 17.5v150q0 10 -7.5 17.5t-17.5 7.5z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM675 1000h-150q-10 0 -17.5 -7.5t-7.5 -17.5v-150q0 -10 7.5 -17.5 t17.5 -7.5h150q10 0 17.5 7.5t7.5 17.5v150q0 10 -7.5 17.5t-17.5 7.5zM675 700h-250q-10 0 -17.5 -7.5t-7.5 -17.5v-50q0 -10 7.5 -17.5t17.5 -7.5h75v-200h-75q-10 0 -17.5 -7.5t-7.5 -17.5v-50q0 -10 7.5 -17.5t17.5 -7.5h350q10 0 17.5 7.5t7.5 17.5v50q0 10 -7.5 17.5 t-17.5 7.5h-75v275q0 10 -7.5 17.5t-17.5 7.5z" />
+<glyph unicode="" d="M525 1200h150q10 0 17.5 -7.5t7.5 -17.5v-194q103 -27 178.5 -102.5t102.5 -178.5h194q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-194q-27 -103 -102.5 -178.5t-178.5 -102.5v-194q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v194 q-103 27 -178.5 102.5t-102.5 178.5h-194q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5h194q27 103 102.5 178.5t178.5 102.5v194q0 10 7.5 17.5t17.5 7.5zM700 893v-168q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v168q-68 -23 -119 -74 t-74 -119h168q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-168q23 -68 74 -119t119 -74v168q0 10 7.5 17.5t17.5 7.5h150q10 0 17.5 -7.5t7.5 -17.5v-168q68 23 119 74t74 119h-168q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5h168 q-23 68 -74 119t-119 74z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 1027q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5 t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5t-57 214.5t-155.5 155.5t-214.5 57zM759 823l64 -64q7 -7 7 -17.5t-7 -17.5l-124 -124l124 -124q7 -7 7 -17.5t-7 -17.5l-64 -64q-7 -7 -17.5 -7t-17.5 7l-124 124l-124 -124q-7 -7 -17.5 -7t-17.5 7l-64 64 q-7 7 -7 17.5t7 17.5l124 124l-124 124q-7 7 -7 17.5t7 17.5l64 64q7 7 17.5 7t17.5 -7l124 -124l124 124q7 7 17.5 7t17.5 -7z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 1027q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5t57 -214.5 t155.5 -155.5t214.5 -57t214.5 57t155.5 155.5t57 214.5t-57 214.5t-155.5 155.5t-214.5 57zM782 788l106 -106q7 -7 7 -17.5t-7 -17.5l-320 -321q-8 -7 -18 -7t-18 7l-202 203q-8 7 -8 17.5t8 17.5l106 106q7 8 17.5 8t17.5 -8l79 -79l197 197q7 7 17.5 7t17.5 -7z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM600 1027q-116 0 -214.5 -57t-155.5 -155.5t-57 -214.5q0 -120 65 -225 l587 587q-105 65 -225 65zM965 819l-584 -584q104 -62 219 -62q116 0 214.5 57t155.5 155.5t57 214.5q0 115 -62 219z" />
+<glyph unicode="" d="M39 582l522 427q16 13 27.5 8t11.5 -26v-291h550q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-550v-291q0 -21 -11.5 -26t-27.5 8l-522 427q-16 13 -16 32t16 32z" />
+<glyph unicode="" d="M639 1009l522 -427q16 -13 16 -32t-16 -32l-522 -427q-16 -13 -27.5 -8t-11.5 26v291h-550q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5h550v291q0 21 11.5 26t27.5 -8z" />
+<glyph unicode="" d="M682 1161l427 -522q13 -16 8 -27.5t-26 -11.5h-291v-550q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v550h-291q-21 0 -26 11.5t8 27.5l427 522q13 16 32 16t32 -16z" />
+<glyph unicode="" d="M550 1200h200q21 0 35.5 -14.5t14.5 -35.5v-550h291q21 0 26 -11.5t-8 -27.5l-427 -522q-13 -16 -32 -16t-32 16l-427 522q-13 16 -8 27.5t26 11.5h291v550q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M639 1109l522 -427q16 -13 16 -32t-16 -32l-522 -427q-16 -13 -27.5 -8t-11.5 26v291q-94 -2 -182 -20t-170.5 -52t-147 -92.5t-100.5 -135.5q5 105 27 193.5t67.5 167t113 135t167 91.5t225.5 42v262q0 21 11.5 26t27.5 -8z" />
+<glyph unicode="" d="M850 1200h300q21 0 35.5 -14.5t14.5 -35.5v-300q0 -21 -10.5 -25t-24.5 10l-94 94l-249 -249q-8 -7 -18 -7t-18 7l-106 106q-7 8 -7 18t7 18l249 249l-94 94q-14 14 -10 24.5t25 10.5zM350 0h-300q-21 0 -35.5 14.5t-14.5 35.5v300q0 21 10.5 25t24.5 -10l94 -94l249 249 q8 7 18 7t18 -7l106 -106q7 -8 7 -18t-7 -18l-249 -249l94 -94q14 -14 10 -24.5t-25 -10.5z" />
+<glyph unicode="" d="M1014 1120l106 -106q7 -8 7 -18t-7 -18l-249 -249l94 -94q14 -14 10 -24.5t-25 -10.5h-300q-21 0 -35.5 14.5t-14.5 35.5v300q0 21 10.5 25t24.5 -10l94 -94l249 249q8 7 18 7t18 -7zM250 600h300q21 0 35.5 -14.5t14.5 -35.5v-300q0 -21 -10.5 -25t-24.5 10l-94 94 l-249 -249q-8 -7 -18 -7t-18 7l-106 106q-7 8 -7 18t7 18l249 249l-94 94q-14 14 -10 24.5t25 10.5z" />
+<glyph unicode="" d="M600 1177q117 0 224 -45.5t184.5 -123t123 -184.5t45.5 -224t-45.5 -224t-123 -184.5t-184.5 -123t-224 -45.5t-224 45.5t-184.5 123t-123 184.5t-45.5 224t45.5 224t123 184.5t184.5 123t224 45.5zM704 900h-208q-20 0 -32 -14.5t-8 -34.5l58 -302q4 -20 21.5 -34.5 t37.5 -14.5h54q20 0 37.5 14.5t21.5 34.5l58 302q4 20 -8 34.5t-32 14.5zM675 400h-150q-10 0 -17.5 -7.5t-7.5 -17.5v-150q0 -10 7.5 -17.5t17.5 -7.5h150q10 0 17.5 7.5t7.5 17.5v150q0 10 -7.5 17.5t-17.5 7.5z" />
+<glyph unicode="" d="M260 1200q9 0 19 -2t15 -4l5 -2q22 -10 44 -23l196 -118q21 -13 36 -24q29 -21 37 -12q11 13 49 35l196 118q22 13 45 23q17 7 38 7q23 0 47 -16.5t37 -33.5l13 -16q14 -21 18 -45l25 -123l8 -44q1 -9 8.5 -14.5t17.5 -5.5h61q10 0 17.5 -7.5t7.5 -17.5v-50 q0 -10 -7.5 -17.5t-17.5 -7.5h-50q-10 0 -17.5 -7.5t-7.5 -17.5v-175h-400v300h-200v-300h-400v175q0 10 -7.5 17.5t-17.5 7.5h-50q-10 0 -17.5 7.5t-7.5 17.5v50q0 10 7.5 17.5t17.5 7.5h61q11 0 18 3t7 8q0 4 9 52l25 128q5 25 19 45q2 3 5 7t13.5 15t21.5 19.5t26.5 15.5 t29.5 7zM915 1079l-166 -162q-7 -7 -5 -12t12 -5h219q10 0 15 7t2 17l-51 149q-3 10 -11 12t-15 -6zM463 917l-177 157q-8 7 -16 5t-11 -12l-51 -143q-3 -10 2 -17t15 -7h231q11 0 12.5 5t-5.5 12zM500 0h-375q-10 0 -17.5 7.5t-7.5 17.5v375h400v-400zM1100 400v-375 q0 -10 -7.5 -17.5t-17.5 -7.5h-375v400h400z" />
+<glyph unicode="" d="M1165 1190q8 3 21 -6.5t13 -17.5q-2 -178 -24.5 -323.5t-55.5 -245.5t-87 -174.5t-102.5 -118.5t-118 -68.5t-118.5 -33t-120 -4.5t-105 9.5t-90 16.5q-61 12 -78 11q-4 1 -12.5 0t-34 -14.5t-52.5 -40.5l-153 -153q-26 -24 -37 -14.5t-11 43.5q0 64 42 102q8 8 50.5 45 t66.5 58q19 17 35 47t13 61q-9 55 -10 102.5t7 111t37 130t78 129.5q39 51 80 88t89.5 63.5t94.5 45t113.5 36t129 31t157.5 37t182 47.5zM1116 1098q-8 9 -22.5 -3t-45.5 -50q-38 -47 -119 -103.5t-142 -89.5l-62 -33q-56 -30 -102 -57t-104 -68t-102.5 -80.5t-85.5 -91 t-64 -104.5q-24 -56 -31 -86t2 -32t31.5 17.5t55.5 59.5q25 30 94 75.5t125.5 77.5t147.5 81q70 37 118.5 69t102 79.5t99 111t86.5 148.5q22 50 24 60t-6 19z" />
+<glyph unicode="" d="M653 1231q-39 -67 -54.5 -131t-10.5 -114.5t24.5 -96.5t47.5 -80t63.5 -62.5t68.5 -46.5t65 -30q-4 7 -17.5 35t-18.5 39.5t-17 39.5t-17 43t-13 42t-9.5 44.5t-2 42t4 43t13.5 39t23 38.5q96 -42 165 -107.5t105 -138t52 -156t13 -159t-19 -149.5q-13 -55 -44 -106.5 t-68 -87t-78.5 -64.5t-72.5 -45t-53 -22q-72 -22 -127 -11q-31 6 -13 19q6 3 17 7q13 5 32.5 21t41 44t38.5 63.5t21.5 81.5t-6.5 94.5t-50 107t-104 115.5q10 -104 -0.5 -189t-37 -140.5t-65 -93t-84 -52t-93.5 -11t-95 24.5q-80 36 -131.5 114t-53.5 171q-2 23 0 49.5 t4.5 52.5t13.5 56t27.5 60t46 64.5t69.5 68.5q-8 -53 -5 -102.5t17.5 -90t34 -68.5t44.5 -39t49 -2q31 13 38.5 36t-4.5 55t-29 64.5t-36 75t-26 75.5q-15 85 2 161.5t53.5 128.5t85.5 92.5t93.5 61t81.5 25.5z" />
+<glyph unicode="" d="M600 1094q82 0 160.5 -22.5t140 -59t116.5 -82.5t94.5 -95t68 -95t42.5 -82.5t14 -57.5t-14 -57.5t-43 -82.5t-68.5 -95t-94.5 -95t-116.5 -82.5t-140 -59t-159.5 -22.5t-159.5 22.5t-140 59t-116.5 82.5t-94.5 95t-68.5 95t-43 82.5t-14 57.5t14 57.5t42.5 82.5t68 95 t94.5 95t116.5 82.5t140 59t160.5 22.5zM888 829q-15 15 -18 12t5 -22q25 -57 25 -119q0 -124 -88 -212t-212 -88t-212 88t-88 212q0 59 23 114q8 19 4.5 22t-17.5 -12q-70 -69 -160 -184q-13 -16 -15 -40.5t9 -42.5q22 -36 47 -71t70 -82t92.5 -81t113 -58.5t133.5 -24.5 t133.5 24t113 58.5t92.5 81.5t70 81.5t47 70.5q11 18 9 42.5t-14 41.5q-90 117 -163 189zM448 727l-35 -36q-15 -15 -19.5 -38.5t4.5 -41.5q37 -68 93 -116q16 -13 38.5 -11t36.5 17l35 34q14 15 12.5 33.5t-16.5 33.5q-44 44 -89 117q-11 18 -28 20t-32 -12z" />
+<glyph unicode="" d="M592 0h-148l31 120q-91 20 -175.5 68.5t-143.5 106.5t-103.5 119t-66.5 110t-22 76q0 21 14 57.5t42.5 82.5t68 95t94.5 95t116.5 82.5t140 59t160.5 22.5q61 0 126 -15l32 121h148zM944 770l47 181q108 -85 176.5 -192t68.5 -159q0 -26 -19.5 -71t-59.5 -102t-93 -112 t-129 -104.5t-158 -75.5l46 173q77 49 136 117t97 131q11 18 9 42.5t-14 41.5q-54 70 -107 130zM310 824q-70 -69 -160 -184q-13 -16 -15 -40.5t9 -42.5q18 -30 39 -60t57 -70.5t74 -73t90 -61t105 -41.5l41 154q-107 18 -178.5 101.5t-71.5 193.5q0 59 23 114q8 19 4.5 22 t-17.5 -12zM448 727l-35 -36q-15 -15 -19.5 -38.5t4.5 -41.5q37 -68 93 -116q16 -13 38.5 -11t36.5 17l12 11l22 86l-3 4q-44 44 -89 117q-11 18 -28 20t-32 -12z" />
+<glyph unicode="" d="M-90 100l642 1066q20 31 48 28.5t48 -35.5l642 -1056q21 -32 7.5 -67.5t-50.5 -35.5h-1294q-37 0 -50.5 34t7.5 66zM155 200h345v75q0 10 7.5 17.5t17.5 7.5h150q10 0 17.5 -7.5t7.5 -17.5v-75h345l-445 723zM496 700h208q20 0 32 -14.5t8 -34.5l-58 -252 q-4 -20 -21.5 -34.5t-37.5 -14.5h-54q-20 0 -37.5 14.5t-21.5 34.5l-58 252q-4 20 8 34.5t32 14.5z" />
+<glyph unicode="" d="M650 1200q62 0 106 -44t44 -106v-339l363 -325q15 -14 26 -38.5t11 -44.5v-41q0 -20 -12 -26.5t-29 5.5l-359 249v-263q100 -93 100 -113v-64q0 -21 -13 -29t-32 1l-205 128l-205 -128q-19 -9 -32 -1t-13 29v64q0 20 100 113v263l-359 -249q-17 -12 -29 -5.5t-12 26.5v41 q0 20 11 44.5t26 38.5l363 325v339q0 62 44 106t106 44z" />
+<glyph unicode="" d="M850 1200h100q21 0 35.5 -14.5t14.5 -35.5v-50h50q21 0 35.5 -14.5t14.5 -35.5v-150h-1100v150q0 21 14.5 35.5t35.5 14.5h50v50q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-50h500v50q0 21 14.5 35.5t35.5 14.5zM1100 800v-750q0 -21 -14.5 -35.5 t-35.5 -14.5h-1000q-21 0 -35.5 14.5t-14.5 35.5v750h1100zM100 600v-100h100v100h-100zM300 600v-100h100v100h-100zM500 600v-100h100v100h-100zM700 600v-100h100v100h-100zM900 600v-100h100v100h-100zM100 400v-100h100v100h-100zM300 400v-100h100v100h-100zM500 400 v-100h100v100h-100zM700 400v-100h100v100h-100zM900 400v-100h100v100h-100zM100 200v-100h100v100h-100zM300 200v-100h100v100h-100zM500 200v-100h100v100h-100zM700 200v-100h100v100h-100zM900 200v-100h100v100h-100z" />
+<glyph unicode="" d="M1135 1165l249 -230q15 -14 15 -35t-15 -35l-249 -230q-14 -14 -24.5 -10t-10.5 25v150h-159l-600 -600h-291q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5h209l600 600h241v150q0 21 10.5 25t24.5 -10zM522 819l-141 -141l-122 122h-209q-21 0 -35.5 14.5 t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5h291zM1135 565l249 -230q15 -14 15 -35t-15 -35l-249 -230q-14 -14 -24.5 -10t-10.5 25v150h-241l-181 181l141 141l122 -122h159v150q0 21 10.5 25t24.5 -10z" />
+<glyph unicode="" d="M100 1100h1000q41 0 70.5 -29.5t29.5 -70.5v-600q0 -41 -29.5 -70.5t-70.5 -29.5h-596l-304 -300v300h-100q-41 0 -70.5 29.5t-29.5 70.5v600q0 41 29.5 70.5t70.5 29.5z" />
+<glyph unicode="" d="M150 1200h200q21 0 35.5 -14.5t14.5 -35.5v-250h-300v250q0 21 14.5 35.5t35.5 14.5zM850 1200h200q21 0 35.5 -14.5t14.5 -35.5v-250h-300v250q0 21 14.5 35.5t35.5 14.5zM1100 800v-300q0 -41 -3 -77.5t-15 -89.5t-32 -96t-58 -89t-89 -77t-129 -51t-174 -20t-174 20 t-129 51t-89 77t-58 89t-32 96t-15 89.5t-3 77.5v300h300v-250v-27v-42.5t1.5 -41t5 -38t10 -35t16.5 -30t25.5 -24.5t35 -19t46.5 -12t60 -4t60 4.5t46.5 12.5t35 19.5t25 25.5t17 30.5t10 35t5 38t2 40.5t-0.5 42v25v250h300z" />
+<glyph unicode="" d="M1100 411l-198 -199l-353 353l-353 -353l-197 199l551 551z" />
+<glyph unicode="" d="M1101 789l-550 -551l-551 551l198 199l353 -353l353 353z" />
+<glyph unicode="" d="M404 1000h746q21 0 35.5 -14.5t14.5 -35.5v-551h150q21 0 25 -10.5t-10 -24.5l-230 -249q-14 -15 -35 -15t-35 15l-230 249q-14 14 -10 24.5t25 10.5h150v401h-381zM135 984l230 -249q14 -14 10 -24.5t-25 -10.5h-150v-400h385l215 -200h-750q-21 0 -35.5 14.5 t-14.5 35.5v550h-150q-21 0 -25 10.5t10 24.5l230 249q14 15 35 15t35 -15z" />
+<glyph unicode="" d="M56 1200h94q17 0 31 -11t18 -27l38 -162h896q24 0 39 -18.5t10 -42.5l-100 -475q-5 -21 -27 -42.5t-55 -21.5h-633l48 -200h535q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-50v-50q0 -21 -14.5 -35.5t-35.5 -14.5t-35.5 14.5t-14.5 35.5v50h-300v-50 q0 -21 -14.5 -35.5t-35.5 -14.5t-35.5 14.5t-14.5 35.5v50h-31q-18 0 -32.5 10t-20.5 19l-5 10l-201 961h-54q-20 0 -35 14.5t-15 35.5t15 35.5t35 14.5z" />
+<glyph unicode="" d="M1200 1000v-100h-1200v100h200q0 41 29.5 70.5t70.5 29.5h300q41 0 70.5 -29.5t29.5 -70.5h500zM0 800h1200v-800h-1200v800z" />
+<glyph unicode="" d="M200 800l-200 -400v600h200q0 41 29.5 70.5t70.5 29.5h300q42 0 71 -29.5t29 -70.5h500v-200h-1000zM1500 700l-300 -700h-1200l300 700h1200z" />
+<glyph unicode="" d="M635 1184l230 -249q14 -14 10 -24.5t-25 -10.5h-150v-601h150q21 0 25 -10.5t-10 -24.5l-230 -249q-14 -15 -35 -15t-35 15l-230 249q-14 14 -10 24.5t25 10.5h150v601h-150q-21 0 -25 10.5t10 24.5l230 249q14 15 35 15t35 -15z" />
+<glyph unicode="" d="M936 864l249 -229q14 -15 14 -35.5t-14 -35.5l-249 -229q-15 -15 -25.5 -10.5t-10.5 24.5v151h-600v-151q0 -20 -10.5 -24.5t-25.5 10.5l-249 229q-14 15 -14 35.5t14 35.5l249 229q15 15 25.5 10.5t10.5 -25.5v-149h600v149q0 21 10.5 25.5t25.5 -10.5z" />
+<glyph unicode="" d="M1169 400l-172 732q-5 23 -23 45.5t-38 22.5h-672q-20 0 -38 -20t-23 -41l-172 -739h1138zM1100 300h-1000q-41 0 -70.5 -29.5t-29.5 -70.5v-100q0 -41 29.5 -70.5t70.5 -29.5h1000q41 0 70.5 29.5t29.5 70.5v100q0 41 -29.5 70.5t-70.5 29.5zM800 100v100h100v-100h-100 zM1000 100v100h100v-100h-100z" />
+<glyph unicode="" d="M1150 1100q21 0 35.5 -14.5t14.5 -35.5v-850q0 -21 -14.5 -35.5t-35.5 -14.5t-35.5 14.5t-14.5 35.5v850q0 21 14.5 35.5t35.5 14.5zM1000 200l-675 200h-38l47 -276q3 -16 -5.5 -20t-29.5 -4h-7h-84q-20 0 -34.5 14t-18.5 35q-55 337 -55 351v250v6q0 16 1 23.5t6.5 14 t17.5 6.5h200l675 250v-850zM0 750v-250q-4 0 -11 0.5t-24 6t-30 15t-24 30t-11 48.5v50q0 26 10.5 46t25 30t29 16t25.5 7z" />
+<glyph unicode="" d="M553 1200h94q20 0 29 -10.5t3 -29.5l-18 -37q83 -19 144 -82.5t76 -140.5l63 -327l118 -173h17q19 0 33 -14.5t14 -35t-13 -40.5t-31 -27q-8 -4 -23 -9.5t-65 -19.5t-103 -25t-132.5 -20t-158.5 -9q-57 0 -115 5t-104 12t-88.5 15.5t-73.5 17.5t-54.5 16t-35.5 12l-11 4 q-18 8 -31 28t-13 40.5t14 35t33 14.5h17l118 173l63 327q15 77 76 140t144 83l-18 32q-6 19 3.5 32t28.5 13zM498 110q50 -6 102 -6q53 0 102 6q-12 -49 -39.5 -79.5t-62.5 -30.5t-63 30.5t-39 79.5z" />
+<glyph unicode="" d="M800 946l224 78l-78 -224l234 -45l-180 -155l180 -155l-234 -45l78 -224l-224 78l-45 -234l-155 180l-155 -180l-45 234l-224 -78l78 224l-234 45l180 155l-180 155l234 45l-78 224l224 -78l45 234l155 -180l155 180z" />
+<glyph unicode="" d="M650 1200h50q40 0 70 -40.5t30 -84.5v-150l-28 -125h328q40 0 70 -40.5t30 -84.5v-100q0 -45 -29 -74l-238 -344q-16 -24 -38 -40.5t-45 -16.5h-250q-7 0 -42 25t-66 50l-31 25h-61q-45 0 -72.5 18t-27.5 57v400q0 36 20 63l145 196l96 198q13 28 37.5 48t51.5 20z M650 1100l-100 -212l-150 -213v-375h100l136 -100h214l250 375v125h-450l50 225v175h-50zM50 800h100q21 0 35.5 -14.5t14.5 -35.5v-500q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v500q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M600 1100h250q23 0 45 -16.5t38 -40.5l238 -344q29 -29 29 -74v-100q0 -44 -30 -84.5t-70 -40.5h-328q28 -118 28 -125v-150q0 -44 -30 -84.5t-70 -40.5h-50q-27 0 -51.5 20t-37.5 48l-96 198l-145 196q-20 27 -20 63v400q0 39 27.5 57t72.5 18h61q124 100 139 100z M50 1000h100q21 0 35.5 -14.5t14.5 -35.5v-500q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v500q0 21 14.5 35.5t35.5 14.5zM636 1000l-136 -100h-100v-375l150 -213l100 -212h50v175l-50 225h450v125l-250 375h-214z" />
+<glyph unicode="" d="M356 873l363 230q31 16 53 -6l110 -112q13 -13 13.5 -32t-11.5 -34l-84 -121h302q84 0 138 -38t54 -110t-55 -111t-139 -39h-106l-131 -339q-6 -21 -19.5 -41t-28.5 -20h-342q-7 0 -90 81t-83 94v525q0 17 14 35.5t28 28.5zM400 792v-503l100 -89h293l131 339 q6 21 19.5 41t28.5 20h203q21 0 30.5 25t0.5 50t-31 25h-456h-7h-6h-5.5t-6 0.5t-5 1.5t-5 2t-4 2.5t-4 4t-2.5 4.5q-12 25 5 47l146 183l-86 83zM50 800h100q21 0 35.5 -14.5t14.5 -35.5v-500q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v500 q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M475 1103l366 -230q2 -1 6 -3.5t14 -10.5t18 -16.5t14.5 -20t6.5 -22.5v-525q0 -13 -86 -94t-93 -81h-342q-15 0 -28.5 20t-19.5 41l-131 339h-106q-85 0 -139.5 39t-54.5 111t54 110t138 38h302l-85 121q-11 15 -10.5 34t13.5 32l110 112q22 22 53 6zM370 945l146 -183 q17 -22 5 -47q-2 -2 -3.5 -4.5t-4 -4t-4 -2.5t-5 -2t-5 -1.5t-6 -0.5h-6h-6.5h-6h-475v-100h221q15 0 29 -20t20 -41l130 -339h294l106 89v503l-342 236zM1050 800h100q21 0 35.5 -14.5t14.5 -35.5v-500q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5 v500q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M550 1294q72 0 111 -55t39 -139v-106l339 -131q21 -6 41 -19.5t20 -28.5v-342q0 -7 -81 -90t-94 -83h-525q-17 0 -35.5 14t-28.5 28l-9 14l-230 363q-16 31 6 53l112 110q13 13 32 13.5t34 -11.5l121 -84v302q0 84 38 138t110 54zM600 972v203q0 21 -25 30.5t-50 0.5 t-25 -31v-456v-7v-6v-5.5t-0.5 -6t-1.5 -5t-2 -5t-2.5 -4t-4 -4t-4.5 -2.5q-25 -12 -47 5l-183 146l-83 -86l236 -339h503l89 100v293l-339 131q-21 6 -41 19.5t-20 28.5zM450 200h500q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-500 q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M350 1100h500q21 0 35.5 14.5t14.5 35.5v100q0 21 -14.5 35.5t-35.5 14.5h-500q-21 0 -35.5 -14.5t-14.5 -35.5v-100q0 -21 14.5 -35.5t35.5 -14.5zM600 306v-106q0 -84 -39 -139t-111 -55t-110 54t-38 138v302l-121 -84q-15 -12 -34 -11.5t-32 13.5l-112 110 q-22 22 -6 53l230 363q1 2 3.5 6t10.5 13.5t16.5 17t20 13.5t22.5 6h525q13 0 94 -83t81 -90v-342q0 -15 -20 -28.5t-41 -19.5zM308 900l-236 -339l83 -86l183 146q22 17 47 5q2 -1 4.5 -2.5t4 -4t2.5 -4t2 -5t1.5 -5t0.5 -6v-5.5v-6v-7v-456q0 -22 25 -31t50 0.5t25 30.5 v203q0 15 20 28.5t41 19.5l339 131v293l-89 100h-503z" />
+<glyph unicode="" d="M600 1178q118 0 225 -45.5t184.5 -123t123 -184.5t45.5 -225t-45.5 -225t-123 -184.5t-184.5 -123t-225 -45.5t-225 45.5t-184.5 123t-123 184.5t-45.5 225t45.5 225t123 184.5t184.5 123t225 45.5zM914 632l-275 223q-16 13 -27.5 8t-11.5 -26v-137h-275 q-10 0 -17.5 -7.5t-7.5 -17.5v-150q0 -10 7.5 -17.5t17.5 -7.5h275v-137q0 -21 11.5 -26t27.5 8l275 223q16 13 16 32t-16 32z" />
+<glyph unicode="" d="M600 1178q118 0 225 -45.5t184.5 -123t123 -184.5t45.5 -225t-45.5 -225t-123 -184.5t-184.5 -123t-225 -45.5t-225 45.5t-184.5 123t-123 184.5t-45.5 225t45.5 225t123 184.5t184.5 123t225 45.5zM561 855l-275 -223q-16 -13 -16 -32t16 -32l275 -223q16 -13 27.5 -8 t11.5 26v137h275q10 0 17.5 7.5t7.5 17.5v150q0 10 -7.5 17.5t-17.5 7.5h-275v137q0 21 -11.5 26t-27.5 -8z" />
+<glyph unicode="" d="M600 1178q118 0 225 -45.5t184.5 -123t123 -184.5t45.5 -225t-45.5 -225t-123 -184.5t-184.5 -123t-225 -45.5t-225 45.5t-184.5 123t-123 184.5t-45.5 225t45.5 225t123 184.5t184.5 123t225 45.5zM855 639l-223 275q-13 16 -32 16t-32 -16l-223 -275q-13 -16 -8 -27.5 t26 -11.5h137v-275q0 -10 7.5 -17.5t17.5 -7.5h150q10 0 17.5 7.5t7.5 17.5v275h137q21 0 26 11.5t-8 27.5z" />
+<glyph unicode="" d="M600 1178q118 0 225 -45.5t184.5 -123t123 -184.5t45.5 -225t-45.5 -225t-123 -184.5t-184.5 -123t-225 -45.5t-225 45.5t-184.5 123t-123 184.5t-45.5 225t45.5 225t123 184.5t184.5 123t225 45.5zM675 900h-150q-10 0 -17.5 -7.5t-7.5 -17.5v-275h-137q-21 0 -26 -11.5 t8 -27.5l223 -275q13 -16 32 -16t32 16l223 275q13 16 8 27.5t-26 11.5h-137v275q0 10 -7.5 17.5t-17.5 7.5z" />
+<glyph unicode="" d="M600 1176q116 0 222.5 -46t184 -123.5t123.5 -184t46 -222.5t-46 -222.5t-123.5 -184t-184 -123.5t-222.5 -46t-222.5 46t-184 123.5t-123.5 184t-46 222.5t46 222.5t123.5 184t184 123.5t222.5 46zM627 1101q-15 -12 -36.5 -20.5t-35.5 -12t-43 -8t-39 -6.5 q-15 -3 -45.5 0t-45.5 -2q-20 -7 -51.5 -26.5t-34.5 -34.5q-3 -11 6.5 -22.5t8.5 -18.5q-3 -34 -27.5 -91t-29.5 -79q-9 -34 5 -93t8 -87q0 -9 17 -44.5t16 -59.5q12 0 23 -5t23.5 -15t19.5 -14q16 -8 33 -15t40.5 -15t34.5 -12q21 -9 52.5 -32t60 -38t57.5 -11 q7 -15 -3 -34t-22.5 -40t-9.5 -38q13 -21 23 -34.5t27.5 -27.5t36.5 -18q0 -7 -3.5 -16t-3.5 -14t5 -17q104 -2 221 112q30 29 46.5 47t34.5 49t21 63q-13 8 -37 8.5t-36 7.5q-15 7 -49.5 15t-51.5 19q-18 0 -41 -0.5t-43 -1.5t-42 -6.5t-38 -16.5q-51 -35 -66 -12 q-4 1 -3.5 25.5t0.5 25.5q-6 13 -26.5 17.5t-24.5 6.5q1 15 -0.5 30.5t-7 28t-18.5 11.5t-31 -21q-23 -25 -42 4q-19 28 -8 58q6 16 22 22q6 -1 26 -1.5t33.5 -4t19.5 -13.5q7 -12 18 -24t21.5 -20.5t20 -15t15.5 -10.5l5 -3q2 12 7.5 30.5t8 34.5t-0.5 32q-3 18 3.5 29 t18 22.5t15.5 24.5q6 14 10.5 35t8 31t15.5 22.5t34 22.5q-6 18 10 36q8 0 24 -1.5t24.5 -1.5t20 4.5t20.5 15.5q-10 23 -31 42.5t-37.5 29.5t-49 27t-43.5 23q0 1 2 8t3 11.5t1.5 10.5t-1 9.5t-4.5 4.5q31 -13 58.5 -14.5t38.5 2.5l12 5q5 28 -9.5 46t-36.5 24t-50 15 t-41 20q-18 -4 -37 0zM613 994q0 -17 8 -42t17 -45t9 -23q-8 1 -39.5 5.5t-52.5 10t-37 16.5q3 11 16 29.5t16 25.5q10 -10 19 -10t14 6t13.5 14.5t16.5 12.5z" />
+<glyph unicode="" d="M756 1157q164 92 306 -9l-259 -138l145 -232l251 126q6 -89 -34 -156.5t-117 -110.5q-60 -34 -127 -39.5t-126 16.5l-596 -596q-15 -16 -36.5 -16t-36.5 16l-111 110q-15 15 -15 36.5t15 37.5l600 599q-34 101 5.5 201.5t135.5 154.5z" />
+<glyph unicode="" horiz-adv-x="1220" d="M100 1196h1000q41 0 70.5 -29.5t29.5 -70.5v-100q0 -41 -29.5 -70.5t-70.5 -29.5h-1000q-41 0 -70.5 29.5t-29.5 70.5v100q0 41 29.5 70.5t70.5 29.5zM1100 1096h-200v-100h200v100zM100 796h1000q41 0 70.5 -29.5t29.5 -70.5v-100q0 -41 -29.5 -70.5t-70.5 -29.5h-1000 q-41 0 -70.5 29.5t-29.5 70.5v100q0 41 29.5 70.5t70.5 29.5zM1100 696h-500v-100h500v100zM100 396h1000q41 0 70.5 -29.5t29.5 -70.5v-100q0 -41 -29.5 -70.5t-70.5 -29.5h-1000q-41 0 -70.5 29.5t-29.5 70.5v100q0 41 29.5 70.5t70.5 29.5zM1100 296h-300v-100h300v100z " />
+<glyph unicode="" d="M150 1200h900q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-900q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5zM700 500v-300l-200 -200v500l-350 500h900z" />
+<glyph unicode="" d="M500 1200h200q41 0 70.5 -29.5t29.5 -70.5v-100h300q41 0 70.5 -29.5t29.5 -70.5v-400h-500v100h-200v-100h-500v400q0 41 29.5 70.5t70.5 29.5h300v100q0 41 29.5 70.5t70.5 29.5zM500 1100v-100h200v100h-200zM1200 400v-200q0 -41 -29.5 -70.5t-70.5 -29.5h-1000 q-41 0 -70.5 29.5t-29.5 70.5v200h1200z" />
+<glyph unicode="" d="M50 1200h300q21 0 25 -10.5t-10 -24.5l-94 -94l199 -199q7 -8 7 -18t-7 -18l-106 -106q-8 -7 -18 -7t-18 7l-199 199l-94 -94q-14 -14 -24.5 -10t-10.5 25v300q0 21 14.5 35.5t35.5 14.5zM850 1200h300q21 0 35.5 -14.5t14.5 -35.5v-300q0 -21 -10.5 -25t-24.5 10l-94 94 l-199 -199q-8 -7 -18 -7t-18 7l-106 106q-7 8 -7 18t7 18l199 199l-94 94q-14 14 -10 24.5t25 10.5zM364 470l106 -106q7 -8 7 -18t-7 -18l-199 -199l94 -94q14 -14 10 -24.5t-25 -10.5h-300q-21 0 -35.5 14.5t-14.5 35.5v300q0 21 10.5 25t24.5 -10l94 -94l199 199 q8 7 18 7t18 -7zM1071 271l94 94q14 14 24.5 10t10.5 -25v-300q0 -21 -14.5 -35.5t-35.5 -14.5h-300q-21 0 -25 10.5t10 24.5l94 94l-199 199q-7 8 -7 18t7 18l106 106q8 7 18 7t18 -7z" />
+<glyph unicode="" d="M596 1192q121 0 231.5 -47.5t190 -127t127 -190t47.5 -231.5t-47.5 -231.5t-127 -190.5t-190 -127t-231.5 -47t-231.5 47t-190.5 127t-127 190.5t-47 231.5t47 231.5t127 190t190.5 127t231.5 47.5zM596 1010q-112 0 -207.5 -55.5t-151 -151t-55.5 -207.5t55.5 -207.5 t151 -151t207.5 -55.5t207.5 55.5t151 151t55.5 207.5t-55.5 207.5t-151 151t-207.5 55.5zM454.5 905q22.5 0 38.5 -16t16 -38.5t-16 -39t-38.5 -16.5t-38.5 16.5t-16 39t16 38.5t38.5 16zM754.5 905q22.5 0 38.5 -16t16 -38.5t-16 -39t-38 -16.5q-14 0 -29 10l-55 -145 q17 -23 17 -51q0 -36 -25.5 -61.5t-61.5 -25.5t-61.5 25.5t-25.5 61.5q0 32 20.5 56.5t51.5 29.5l122 126l1 1q-9 14 -9 28q0 23 16 39t38.5 16zM345.5 709q22.5 0 38.5 -16t16 -38.5t-16 -38.5t-38.5 -16t-38.5 16t-16 38.5t16 38.5t38.5 16zM854.5 709q22.5 0 38.5 -16 t16 -38.5t-16 -38.5t-38.5 -16t-38.5 16t-16 38.5t16 38.5t38.5 16z" />
+<glyph unicode="" d="M546 173l469 470q91 91 99 192q7 98 -52 175.5t-154 94.5q-22 4 -47 4q-34 0 -66.5 -10t-56.5 -23t-55.5 -38t-48 -41.5t-48.5 -47.5q-376 -375 -391 -390q-30 -27 -45 -41.5t-37.5 -41t-32 -46.5t-16 -47.5t-1.5 -56.5q9 -62 53.5 -95t99.5 -33q74 0 125 51l548 548 q36 36 20 75q-7 16 -21.5 26t-32.5 10q-26 0 -50 -23q-13 -12 -39 -38l-341 -338q-15 -15 -35.5 -15.5t-34.5 13.5t-14 34.5t14 34.5q327 333 361 367q35 35 67.5 51.5t78.5 16.5q14 0 29 -1q44 -8 74.5 -35.5t43.5 -68.5q14 -47 2 -96.5t-47 -84.5q-12 -11 -32 -32 t-79.5 -81t-114.5 -115t-124.5 -123.5t-123 -119.5t-96.5 -89t-57 -45q-56 -27 -120 -27q-70 0 -129 32t-93 89q-48 78 -35 173t81 163l511 511q71 72 111 96q91 55 198 55q80 0 152 -33q78 -36 129.5 -103t66.5 -154q17 -93 -11 -183.5t-94 -156.5l-482 -476 q-15 -15 -36 -16t-37 14t-17.5 34t14.5 35z" />
+<glyph unicode="" d="M649 949q48 68 109.5 104t121.5 38.5t118.5 -20t102.5 -64t71 -100.5t27 -123q0 -57 -33.5 -117.5t-94 -124.5t-126.5 -127.5t-150 -152.5t-146 -174q-62 85 -145.5 174t-150 152.5t-126.5 127.5t-93.5 124.5t-33.5 117.5q0 64 28 123t73 100.5t104 64t119 20 t120.5 -38.5t104.5 -104zM896 972q-33 0 -64.5 -19t-56.5 -46t-47.5 -53.5t-43.5 -45.5t-37.5 -19t-36 19t-40 45.5t-43 53.5t-54 46t-65.5 19q-67 0 -122.5 -55.5t-55.5 -132.5q0 -23 13.5 -51t46 -65t57.5 -63t76 -75l22 -22q15 -14 44 -44t50.5 -51t46 -44t41 -35t23 -12 t23.5 12t42.5 36t46 44t52.5 52t44 43q4 4 12 13q43 41 63.5 62t52 55t46 55t26 46t11.5 44q0 79 -53 133.5t-120 54.5z" />
+<glyph unicode="" d="M776.5 1214q93.5 0 159.5 -66l141 -141q66 -66 66 -160q0 -42 -28 -95.5t-62 -87.5l-29 -29q-31 53 -77 99l-18 18l95 95l-247 248l-389 -389l212 -212l-105 -106l-19 18l-141 141q-66 66 -66 159t66 159l283 283q65 66 158.5 66zM600 706l105 105q10 -8 19 -17l141 -141 q66 -66 66 -159t-66 -159l-283 -283q-66 -66 -159 -66t-159 66l-141 141q-66 66 -66 159.5t66 159.5l55 55q29 -55 75 -102l18 -17l-95 -95l247 -248l389 389z" />
+<glyph unicode="" d="M603 1200q85 0 162 -15t127 -38t79 -48t29 -46v-953q0 -41 -29.5 -70.5t-70.5 -29.5h-600q-41 0 -70.5 29.5t-29.5 70.5v953q0 21 30 46.5t81 48t129 37.5t163 15zM300 1000v-700h600v700h-600zM600 254q-43 0 -73.5 -30.5t-30.5 -73.5t30.5 -73.5t73.5 -30.5t73.5 30.5 t30.5 73.5t-30.5 73.5t-73.5 30.5z" />
+<glyph unicode="" d="M902 1185l283 -282q15 -15 15 -36t-14.5 -35.5t-35.5 -14.5t-35 15l-36 35l-279 -267v-300l-212 210l-308 -307l-280 -203l203 280l307 308l-210 212h300l267 279l-35 36q-15 14 -15 35t14.5 35.5t35.5 14.5t35 -15z" />
+<glyph unicode="" d="M700 1248v-78q38 -5 72.5 -14.5t75.5 -31.5t71 -53.5t52 -84t24 -118.5h-159q-4 36 -10.5 59t-21 45t-40 35.5t-64.5 20.5v-307l64 -13q34 -7 64 -16.5t70 -32t67.5 -52.5t47.5 -80t20 -112q0 -139 -89 -224t-244 -97v-77h-100v79q-150 16 -237 103q-40 40 -52.5 93.5 t-15.5 139.5h139q5 -77 48.5 -126t117.5 -65v335l-27 8q-46 14 -79 26.5t-72 36t-63 52t-40 72.5t-16 98q0 70 25 126t67.5 92t94.5 57t110 27v77h100zM600 754v274q-29 -4 -50 -11t-42 -21.5t-31.5 -41.5t-10.5 -65q0 -29 7 -50.5t16.5 -34t28.5 -22.5t31.5 -14t37.5 -10 q9 -3 13 -4zM700 547v-310q22 2 42.5 6.5t45 15.5t41.5 27t29 42t12 59.5t-12.5 59.5t-38 44.5t-53 31t-66.5 24.5z" />
+<glyph unicode="" d="M561 1197q84 0 160.5 -40t123.5 -109.5t47 -147.5h-153q0 40 -19.5 71.5t-49.5 48.5t-59.5 26t-55.5 9q-37 0 -79 -14.5t-62 -35.5q-41 -44 -41 -101q0 -26 13.5 -63t26.5 -61t37 -66q6 -9 9 -14h241v-100h-197q8 -50 -2.5 -115t-31.5 -95q-45 -62 -99 -112 q34 10 83 17.5t71 7.5q32 1 102 -16t104 -17q83 0 136 30l50 -147q-31 -19 -58 -30.5t-55 -15.5t-42 -4.5t-46 -0.5q-23 0 -76 17t-111 32.5t-96 11.5q-39 -3 -82 -16t-67 -25l-23 -11l-55 145q4 3 16 11t15.5 10.5t13 9t15.5 12t14.5 14t17.5 18.5q48 55 54 126.5 t-30 142.5h-221v100h166q-23 47 -44 104q-7 20 -12 41.5t-6 55.5t6 66.5t29.5 70.5t58.5 71q97 88 263 88z" />
+<glyph unicode="" d="M400 300h150q21 0 25 -11t-10 -25l-230 -250q-14 -15 -35 -15t-35 15l-230 250q-14 14 -10 25t25 11h150v900h200v-900zM935 1184l230 -249q14 -14 10 -24.5t-25 -10.5h-150v-900h-200v900h-150q-21 0 -25 10.5t10 24.5l230 249q14 15 35 15t35 -15z" />
+<glyph unicode="" d="M1000 700h-100v100h-100v-100h-100v500h300v-500zM400 300h150q21 0 25 -11t-10 -25l-230 -250q-14 -15 -35 -15t-35 15l-230 250q-14 14 -10 25t25 11h150v900h200v-900zM801 1100v-200h100v200h-100zM1000 350l-200 -250h200v-100h-300v150l200 250h-200v100h300v-150z " />
+<glyph unicode="" d="M400 300h150q21 0 25 -11t-10 -25l-230 -250q-14 -15 -35 -15t-35 15l-230 250q-14 14 -10 25t25 11h150v900h200v-900zM1000 1050l-200 -250h200v-100h-300v150l200 250h-200v100h300v-150zM1000 0h-100v100h-100v-100h-100v500h300v-500zM801 400v-200h100v200h-100z " />
+<glyph unicode="" d="M400 300h150q21 0 25 -11t-10 -25l-230 -250q-14 -15 -35 -15t-35 15l-230 250q-14 14 -10 25t25 11h150v900h200v-900zM1000 700h-100v400h-100v100h200v-500zM1100 0h-100v100h-200v400h300v-500zM901 400v-200h100v200h-100z" />
+<glyph unicode="" d="M400 300h150q21 0 25 -11t-10 -25l-230 -250q-14 -15 -35 -15t-35 15l-230 250q-14 14 -10 25t25 11h150v900h200v-900zM1100 700h-100v100h-200v400h300v-500zM901 1100v-200h100v200h-100zM1000 0h-100v400h-100v100h200v-500z" />
+<glyph unicode="" d="M400 300h150q21 0 25 -11t-10 -25l-230 -250q-14 -15 -35 -15t-35 15l-230 250q-14 14 -10 25t25 11h150v900h200v-900zM900 1000h-200v200h200v-200zM1000 700h-300v200h300v-200zM1100 400h-400v200h400v-200zM1200 100h-500v200h500v-200z" />
+<glyph unicode="" d="M400 300h150q21 0 25 -11t-10 -25l-230 -250q-14 -15 -35 -15t-35 15l-230 250q-14 14 -10 25t25 11h150v900h200v-900zM1200 1000h-500v200h500v-200zM1100 700h-400v200h400v-200zM1000 400h-300v200h300v-200zM900 100h-200v200h200v-200z" />
+<glyph unicode="" d="M350 1100h400q162 0 256 -93.5t94 -256.5v-400q0 -165 -93.5 -257.5t-256.5 -92.5h-400q-165 0 -257.5 92.5t-92.5 257.5v400q0 165 92.5 257.5t257.5 92.5zM800 900h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5 v500q0 41 -29.5 70.5t-70.5 29.5z" />
+<glyph unicode="" d="M350 1100h400q165 0 257.5 -92.5t92.5 -257.5v-400q0 -165 -92.5 -257.5t-257.5 -92.5h-400q-163 0 -256.5 92.5t-93.5 257.5v400q0 163 94 256.5t256 93.5zM800 900h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5 v500q0 41 -29.5 70.5t-70.5 29.5zM440 770l253 -190q17 -12 17 -30t-17 -30l-253 -190q-16 -12 -28 -6.5t-12 26.5v400q0 21 12 26.5t28 -6.5z" />
+<glyph unicode="" d="M350 1100h400q163 0 256.5 -94t93.5 -256v-400q0 -165 -92.5 -257.5t-257.5 -92.5h-400q-165 0 -257.5 92.5t-92.5 257.5v400q0 163 92.5 256.5t257.5 93.5zM800 900h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5 v500q0 41 -29.5 70.5t-70.5 29.5zM350 700h400q21 0 26.5 -12t-6.5 -28l-190 -253q-12 -17 -30 -17t-30 17l-190 253q-12 16 -6.5 28t26.5 12z" />
+<glyph unicode="" d="M350 1100h400q165 0 257.5 -92.5t92.5 -257.5v-400q0 -163 -92.5 -256.5t-257.5 -93.5h-400q-163 0 -256.5 94t-93.5 256v400q0 165 92.5 257.5t257.5 92.5zM800 900h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5 v500q0 41 -29.5 70.5t-70.5 29.5zM580 693l190 -253q12 -16 6.5 -28t-26.5 -12h-400q-21 0 -26.5 12t6.5 28l190 253q12 17 30 17t30 -17z" />
+<glyph unicode="" d="M550 1100h400q165 0 257.5 -92.5t92.5 -257.5v-400q0 -165 -92.5 -257.5t-257.5 -92.5h-400q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5h450q41 0 70.5 29.5t29.5 70.5v500q0 41 -29.5 70.5t-70.5 29.5h-450q-21 0 -35.5 14.5t-14.5 35.5v100 q0 21 14.5 35.5t35.5 14.5zM338 867l324 -284q16 -14 16 -33t-16 -33l-324 -284q-16 -14 -27 -9t-11 26v150h-250q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5h250v150q0 21 11 26t27 -9z" />
+<glyph unicode="" d="M793 1182l9 -9q8 -10 5 -27q-3 -11 -79 -225.5t-78 -221.5l300 1q24 0 32.5 -17.5t-5.5 -35.5q-1 0 -133.5 -155t-267 -312.5t-138.5 -162.5q-12 -15 -26 -15h-9l-9 8q-9 11 -4 32q2 9 42 123.5t79 224.5l39 110h-302q-23 0 -31 19q-10 21 6 41q75 86 209.5 237.5 t228 257t98.5 111.5q9 16 25 16h9z" />
+<glyph unicode="" d="M350 1100h400q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-450q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h450q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-165 0 -257.5 92.5t-92.5 257.5v400 q0 165 92.5 257.5t257.5 92.5zM938 867l324 -284q16 -14 16 -33t-16 -33l-324 -284q-16 -14 -27 -9t-11 26v150h-250q-21 0 -35.5 14.5t-14.5 35.5v200q0 21 14.5 35.5t35.5 14.5h250v150q0 21 11 26t27 -9z" />
+<glyph unicode="" d="M750 1200h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -10.5 -25t-24.5 10l-109 109l-312 -312q-15 -15 -35.5 -15t-35.5 15l-141 141q-15 15 -15 35.5t15 35.5l312 312l-109 109q-14 14 -10 24.5t25 10.5zM456 900h-156q-41 0 -70.5 -29.5t-29.5 -70.5v-500 q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v148l200 200v-298q0 -165 -93.5 -257.5t-256.5 -92.5h-400q-165 0 -257.5 92.5t-92.5 257.5v400q0 165 92.5 257.5t257.5 92.5h300z" />
+<glyph unicode="" d="M600 1186q119 0 227.5 -46.5t187 -125t125 -187t46.5 -227.5t-46.5 -227.5t-125 -187t-187 -125t-227.5 -46.5t-227.5 46.5t-187 125t-125 187t-46.5 227.5t46.5 227.5t125 187t187 125t227.5 46.5zM600 1022q-115 0 -212 -56.5t-153.5 -153.5t-56.5 -212t56.5 -212 t153.5 -153.5t212 -56.5t212 56.5t153.5 153.5t56.5 212t-56.5 212t-153.5 153.5t-212 56.5zM600 794q80 0 137 -57t57 -137t-57 -137t-137 -57t-137 57t-57 137t57 137t137 57z" />
+<glyph unicode="" d="M450 1200h200q21 0 35.5 -14.5t14.5 -35.5v-350h245q20 0 25 -11t-9 -26l-383 -426q-14 -15 -33.5 -15t-32.5 15l-379 426q-13 15 -8.5 26t25.5 11h250v350q0 21 14.5 35.5t35.5 14.5zM50 300h1000q21 0 35.5 -14.5t14.5 -35.5v-250h-1100v250q0 21 14.5 35.5t35.5 14.5z M900 200v-50h100v50h-100z" />
+<glyph unicode="" d="M583 1182l378 -435q14 -15 9 -31t-26 -16h-244v-250q0 -20 -17 -35t-39 -15h-200q-20 0 -32 14.5t-12 35.5v250h-250q-20 0 -25.5 16.5t8.5 31.5l383 431q14 16 33.5 17t33.5 -14zM50 300h1000q21 0 35.5 -14.5t14.5 -35.5v-250h-1100v250q0 21 14.5 35.5t35.5 14.5z M900 200v-50h100v50h-100z" />
+<glyph unicode="" d="M396 723l369 369q7 7 17.5 7t17.5 -7l139 -139q7 -8 7 -18.5t-7 -17.5l-525 -525q-7 -8 -17.5 -8t-17.5 8l-292 291q-7 8 -7 18t7 18l139 139q8 7 18.5 7t17.5 -7zM50 300h1000q21 0 35.5 -14.5t14.5 -35.5v-250h-1100v250q0 21 14.5 35.5t35.5 14.5zM900 200v-50h100v50 h-100z" />
+<glyph unicode="" d="M135 1023l142 142q14 14 35 14t35 -14l77 -77l-212 -212l-77 76q-14 15 -14 36t14 35zM655 855l210 210q14 14 24.5 10t10.5 -25l-2 -599q-1 -20 -15.5 -35t-35.5 -15l-597 -1q-21 0 -25 10.5t10 24.5l208 208l-154 155l212 212zM50 300h1000q21 0 35.5 -14.5t14.5 -35.5 v-250h-1100v250q0 21 14.5 35.5t35.5 14.5zM900 200v-50h100v50h-100z" />
+<glyph unicode="" d="M350 1200l599 -2q20 -1 35 -15.5t15 -35.5l1 -597q0 -21 -10.5 -25t-24.5 10l-208 208l-155 -154l-212 212l155 154l-210 210q-14 14 -10 24.5t25 10.5zM524 512l-76 -77q-15 -14 -36 -14t-35 14l-142 142q-14 14 -14 35t14 35l77 77zM50 300h1000q21 0 35.5 -14.5 t14.5 -35.5v-250h-1100v250q0 21 14.5 35.5t35.5 14.5zM900 200v-50h100v50h-100z" />
+<glyph unicode="" d="M1200 103l-483 276l-314 -399v423h-399l1196 796v-1096zM483 424v-230l683 953z" />
+<glyph unicode="" d="M1100 1000v-850q0 -21 -14.5 -35.5t-35.5 -14.5h-150v400h-700v-400h-150q-21 0 -35.5 14.5t-14.5 35.5v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100zM700 1000h-100v200h100v-200z" />
+<glyph unicode="" d="M1100 1000l-2 -149l-299 -299l-95 95q-9 9 -21.5 9t-21.5 -9l-149 -147h-312v-400h-150q-21 0 -35.5 14.5t-14.5 35.5v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100zM700 1000h-100v200h100v-200zM1132 638l106 -106q7 -7 7 -17.5t-7 -17.5l-420 -421q-8 -7 -18 -7 t-18 7l-202 203q-8 7 -8 17.5t8 17.5l106 106q7 8 17.5 8t17.5 -8l79 -79l297 297q7 7 17.5 7t17.5 -7z" />
+<glyph unicode="" d="M1100 1000v-269l-103 -103l-134 134q-15 15 -33.5 16.5t-34.5 -12.5l-266 -266h-329v-400h-150q-21 0 -35.5 14.5t-14.5 35.5v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100zM700 1000h-100v200h100v-200zM1202 572l70 -70q15 -15 15 -35.5t-15 -35.5l-131 -131 l131 -131q15 -15 15 -35.5t-15 -35.5l-70 -70q-15 -15 -35.5 -15t-35.5 15l-131 131l-131 -131q-15 -15 -35.5 -15t-35.5 15l-70 70q-15 15 -15 35.5t15 35.5l131 131l-131 131q-15 15 -15 35.5t15 35.5l70 70q15 15 35.5 15t35.5 -15l131 -131l131 131q15 15 35.5 15 t35.5 -15z" />
+<glyph unicode="" d="M1100 1000v-300h-350q-21 0 -35.5 -14.5t-14.5 -35.5v-150h-500v-400h-150q-21 0 -35.5 14.5t-14.5 35.5v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100zM700 1000h-100v200h100v-200zM850 600h100q21 0 35.5 -14.5t14.5 -35.5v-250h150q21 0 25 -10.5t-10 -24.5 l-230 -230q-14 -14 -35 -14t-35 14l-230 230q-14 14 -10 24.5t25 10.5h150v250q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M1100 1000v-400l-165 165q-14 15 -35 15t-35 -15l-263 -265h-402v-400h-150q-21 0 -35.5 14.5t-14.5 35.5v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100zM700 1000h-100v200h100v-200zM935 565l230 -229q14 -15 10 -25.5t-25 -10.5h-150v-250q0 -20 -14.5 -35 t-35.5 -15h-100q-21 0 -35.5 15t-14.5 35v250h-150q-21 0 -25 10.5t10 25.5l230 229q14 15 35 15t35 -15z" />
+<glyph unicode="" d="M50 1100h1100q21 0 35.5 -14.5t14.5 -35.5v-150h-1200v150q0 21 14.5 35.5t35.5 14.5zM1200 800v-550q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5v550h1200zM100 500v-200h400v200h-400z" />
+<glyph unicode="" d="M935 1165l248 -230q14 -14 14 -35t-14 -35l-248 -230q-14 -14 -24.5 -10t-10.5 25v150h-400v200h400v150q0 21 10.5 25t24.5 -10zM200 800h-50q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5h50v-200zM400 800h-100v200h100v-200zM18 435l247 230 q14 14 24.5 10t10.5 -25v-150h400v-200h-400v-150q0 -21 -10.5 -25t-24.5 10l-247 230q-15 14 -15 35t15 35zM900 300h-100v200h100v-200zM1000 500h51q20 0 34.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-34.5 -14.5h-51v200z" />
+<glyph unicode="" d="M862 1073l276 116q25 18 43.5 8t18.5 -41v-1106q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v397q-4 1 -11 5t-24 17.5t-30 29t-24 42t-11 56.5v359q0 31 18.5 65t43.5 52zM550 1200q22 0 34.5 -12.5t14.5 -24.5l1 -13v-450q0 -28 -10.5 -59.5 t-25 -56t-29 -45t-25.5 -31.5l-10 -11v-447q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v447q-4 4 -11 11.5t-24 30.5t-30 46t-24 55t-11 60v450q0 2 0.5 5.5t4 12t8.5 15t14.5 12t22.5 5.5q20 0 32.5 -12.5t14.5 -24.5l3 -13v-350h100v350v5.5t2.5 12 t7 15t15 12t25.5 5.5q23 0 35.5 -12.5t13.5 -24.5l1 -13v-350h100v350q0 2 0.5 5.5t3 12t7 15t15 12t24.5 5.5z" />
+<glyph unicode="" d="M1200 1100v-56q-4 0 -11 -0.5t-24 -3t-30 -7.5t-24 -15t-11 -24v-888q0 -22 25 -34.5t50 -13.5l25 -2v-56h-400v56q75 0 87.5 6.5t12.5 43.5v394h-500v-394q0 -37 12.5 -43.5t87.5 -6.5v-56h-400v56q4 0 11 0.5t24 3t30 7.5t24 15t11 24v888q0 22 -25 34.5t-50 13.5 l-25 2v56h400v-56q-75 0 -87.5 -6.5t-12.5 -43.5v-394h500v394q0 37 -12.5 43.5t-87.5 6.5v56h400z" />
+<glyph unicode="" d="M675 1000h375q21 0 35.5 -14.5t14.5 -35.5v-150h-105l-295 -98v98l-200 200h-400l100 100h375zM100 900h300q41 0 70.5 -29.5t29.5 -70.5v-500q0 -41 -29.5 -70.5t-70.5 -29.5h-300q-41 0 -70.5 29.5t-29.5 70.5v500q0 41 29.5 70.5t70.5 29.5zM100 800v-200h300v200 h-300zM1100 535l-400 -133v163l400 133v-163zM100 500v-200h300v200h-300zM1100 398v-248q0 -21 -14.5 -35.5t-35.5 -14.5h-375l-100 -100h-375l-100 100h400l200 200h105z" />
+<glyph unicode="" d="M17 1007l162 162q17 17 40 14t37 -22l139 -194q14 -20 11 -44.5t-20 -41.5l-119 -118q102 -142 228 -268t267 -227l119 118q17 17 42.5 19t44.5 -12l192 -136q19 -14 22.5 -37.5t-13.5 -40.5l-163 -162q-3 -1 -9.5 -1t-29.5 2t-47.5 6t-62.5 14.5t-77.5 26.5t-90 42.5 t-101.5 60t-111 83t-119 108.5q-74 74 -133.5 150.5t-94.5 138.5t-60 119.5t-34.5 100t-15 74.5t-4.5 48z" />
+<glyph unicode="" d="M600 1100q92 0 175 -10.5t141.5 -27t108.5 -36.5t81.5 -40t53.5 -37t31 -27l9 -10v-200q0 -21 -14.5 -33t-34.5 -9l-202 34q-20 3 -34.5 20t-14.5 38v146q-141 24 -300 24t-300 -24v-146q0 -21 -14.5 -38t-34.5 -20l-202 -34q-20 -3 -34.5 9t-14.5 33v200q3 4 9.5 10.5 t31 26t54 37.5t80.5 39.5t109 37.5t141 26.5t175 10.5zM600 795q56 0 97 -9.5t60 -23.5t30 -28t12 -24l1 -10v-50l365 -303q14 -15 24.5 -40t10.5 -45v-212q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5v212q0 20 10.5 45t24.5 40l365 303v50 q0 4 1 10.5t12 23t30 29t60 22.5t97 10z" />
+<glyph unicode="" d="M1100 700l-200 -200h-600l-200 200v500h200v-200h200v200h200v-200h200v200h200v-500zM250 400h700q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-12l137 -100h-950l137 100h-12q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5zM50 100h1100q21 0 35.5 -14.5 t14.5 -35.5v-50h-1200v50q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M700 1100h-100q-41 0 -70.5 -29.5t-29.5 -70.5v-1000h300v1000q0 41 -29.5 70.5t-70.5 29.5zM1100 800h-100q-41 0 -70.5 -29.5t-29.5 -70.5v-700h300v700q0 41 -29.5 70.5t-70.5 29.5zM400 0h-300v400q0 41 29.5 70.5t70.5 29.5h100q41 0 70.5 -29.5t29.5 -70.5v-400z " />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM500 700h-200v-100h200v-300h-300v100h200v100h-200v300h300v-100zM900 700v-300l-100 -100h-200v500h200z M700 700v-300h100v300h-100z" />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM500 300h-100v200h-100v-200h-100v500h100v-200h100v200h100v-500zM900 700v-300l-100 -100h-200v500h200z M700 700v-300h100v300h-100z" />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM500 700h-200v-300h200v-100h-300v500h300v-100zM900 700h-200v-300h200v-100h-300v500h300v-100z" />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM500 400l-300 150l300 150v-300zM900 550l-300 -150v300z" />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM900 300h-700v500h700v-500zM800 700h-130q-38 0 -66.5 -43t-28.5 -108t27 -107t68 -42h130v300zM300 700v-300 h130q41 0 68 42t27 107t-28.5 108t-66.5 43h-130z" />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM500 700h-200v-100h200v-300h-300v100h200v100h-200v300h300v-100zM900 300h-100v400h-100v100h200v-500z M700 300h-100v100h100v-100z" />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM300 700h200v-400h-300v500h100v-100zM900 300h-100v400h-100v100h200v-500zM300 600v-200h100v200h-100z M700 300h-100v100h100v-100z" />
+<glyph unicode="" d="M200 1100h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212v500q0 124 88 212t212 88zM100 900v-700h900v700h-900zM500 500l-199 -200h-100v50l199 200v150h-200v100h300v-300zM900 300h-100v400h-100v100h200v-500zM701 300h-100 v100h100v-100z" />
+<glyph unicode="" d="M600 1191q120 0 229.5 -47t188.5 -126t126 -188.5t47 -229.5t-47 -229.5t-126 -188.5t-188.5 -126t-229.5 -47t-229.5 47t-188.5 126t-126 188.5t-47 229.5t47 229.5t126 188.5t188.5 126t229.5 47zM600 1021q-114 0 -211 -56.5t-153.5 -153.5t-56.5 -211t56.5 -211 t153.5 -153.5t211 -56.5t211 56.5t153.5 153.5t56.5 211t-56.5 211t-153.5 153.5t-211 56.5zM800 700h-300v-200h300v-100h-300l-100 100v200l100 100h300v-100z" />
+<glyph unicode="" d="M600 1191q120 0 229.5 -47t188.5 -126t126 -188.5t47 -229.5t-47 -229.5t-126 -188.5t-188.5 -126t-229.5 -47t-229.5 47t-188.5 126t-126 188.5t-47 229.5t47 229.5t126 188.5t188.5 126t229.5 47zM600 1021q-114 0 -211 -56.5t-153.5 -153.5t-56.5 -211t56.5 -211 t153.5 -153.5t211 -56.5t211 56.5t153.5 153.5t56.5 211t-56.5 211t-153.5 153.5t-211 56.5zM800 700v-100l-50 -50l100 -100v-50h-100l-100 100h-150v-100h-100v400h300zM500 700v-100h200v100h-200z" />
+<glyph unicode="" d="M503 1089q110 0 200.5 -59.5t134.5 -156.5q44 14 90 14q120 0 205 -86.5t85 -207t-85 -207t-205 -86.5h-128v250q0 21 -14.5 35.5t-35.5 14.5h-300q-21 0 -35.5 -14.5t-14.5 -35.5v-250h-222q-80 0 -136 57.5t-56 136.5q0 69 43 122.5t108 67.5q-2 19 -2 37q0 100 49 185 t134 134t185 49zM525 500h150q10 0 17.5 -7.5t7.5 -17.5v-275h137q21 0 26 -11.5t-8 -27.5l-223 -244q-13 -16 -32 -16t-32 16l-223 244q-13 16 -8 27.5t26 11.5h137v275q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M502 1089q110 0 201 -59.5t135 -156.5q43 15 89 15q121 0 206 -86.5t86 -206.5q0 -99 -60 -181t-150 -110l-378 360q-13 16 -31.5 16t-31.5 -16l-381 -365h-9q-79 0 -135.5 57.5t-56.5 136.5q0 69 43 122.5t108 67.5q-2 19 -2 38q0 100 49 184.5t133.5 134t184.5 49.5z M632 467l223 -228q13 -16 8 -27.5t-26 -11.5h-137v-275q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v275h-137q-21 0 -26 11.5t8 27.5q199 204 223 228q19 19 31.5 19t32.5 -19z" />
+<glyph unicode="" d="M700 100v100h400l-270 300h170l-270 300h170l-300 333l-300 -333h170l-270 -300h170l-270 -300h400v-100h-50q-21 0 -35.5 -14.5t-14.5 -35.5v-50h400v50q0 21 -14.5 35.5t-35.5 14.5h-50z" />
+<glyph unicode="" d="M600 1179q94 0 167.5 -56.5t99.5 -145.5q89 -6 150.5 -71.5t61.5 -155.5q0 -61 -29.5 -112.5t-79.5 -82.5q9 -29 9 -55q0 -74 -52.5 -126.5t-126.5 -52.5q-55 0 -100 30v-251q21 0 35.5 -14.5t14.5 -35.5v-50h-300v50q0 21 14.5 35.5t35.5 14.5v251q-45 -30 -100 -30 q-74 0 -126.5 52.5t-52.5 126.5q0 18 4 38q-47 21 -75.5 65t-28.5 97q0 74 52.5 126.5t126.5 52.5q5 0 23 -2q0 2 -1 10t-1 13q0 116 81.5 197.5t197.5 81.5z" />
+<glyph unicode="" d="M1010 1010q111 -111 150.5 -260.5t0 -299t-150.5 -260.5q-83 -83 -191.5 -126.5t-218.5 -43.5t-218.5 43.5t-191.5 126.5q-111 111 -150.5 260.5t0 299t150.5 260.5q83 83 191.5 126.5t218.5 43.5t218.5 -43.5t191.5 -126.5zM476 1065q-4 0 -8 -1q-121 -34 -209.5 -122.5 t-122.5 -209.5q-4 -12 2.5 -23t18.5 -14l36 -9q3 -1 7 -1q23 0 29 22q27 96 98 166q70 71 166 98q11 3 17.5 13.5t3.5 22.5l-9 35q-3 13 -14 19q-7 4 -15 4zM512 920q-4 0 -9 -2q-80 -24 -138.5 -82.5t-82.5 -138.5q-4 -13 2 -24t19 -14l34 -9q4 -1 8 -1q22 0 28 21 q18 58 58.5 98.5t97.5 58.5q12 3 18 13.5t3 21.5l-9 35q-3 12 -14 19q-7 4 -15 4zM719.5 719.5q-49.5 49.5 -119.5 49.5t-119.5 -49.5t-49.5 -119.5t49.5 -119.5t119.5 -49.5t119.5 49.5t49.5 119.5t-49.5 119.5zM855 551q-22 0 -28 -21q-18 -58 -58.5 -98.5t-98.5 -57.5 q-11 -4 -17 -14.5t-3 -21.5l9 -35q3 -12 14 -19q7 -4 15 -4q4 0 9 2q80 24 138.5 82.5t82.5 138.5q4 13 -2.5 24t-18.5 14l-34 9q-4 1 -8 1zM1000 515q-23 0 -29 -22q-27 -96 -98 -166q-70 -71 -166 -98q-11 -3 -17.5 -13.5t-3.5 -22.5l9 -35q3 -13 14 -19q7 -4 15 -4 q4 0 8 1q121 34 209.5 122.5t122.5 209.5q4 12 -2.5 23t-18.5 14l-36 9q-3 1 -7 1z" />
+<glyph unicode="" d="M700 800h300v-380h-180v200h-340v-200h-380v755q0 10 7.5 17.5t17.5 7.5h575v-400zM1000 900h-200v200zM700 300h162l-212 -212l-212 212h162v200h100v-200zM520 0h-395q-10 0 -17.5 7.5t-7.5 17.5v395zM1000 220v-195q0 -10 -7.5 -17.5t-17.5 -7.5h-195z" />
+<glyph unicode="" d="M700 800h300v-520l-350 350l-550 -550v1095q0 10 7.5 17.5t17.5 7.5h575v-400zM1000 900h-200v200zM862 200h-162v-200h-100v200h-162l212 212zM480 0h-355q-10 0 -17.5 7.5t-7.5 17.5v55h380v-80zM1000 80v-55q0 -10 -7.5 -17.5t-17.5 -7.5h-155v80h180z" />
+<glyph unicode="" d="M1162 800h-162v-200h100l100 -100h-300v300h-162l212 212zM200 800h200q27 0 40 -2t29.5 -10.5t23.5 -30t7 -57.5h300v-100h-600l-200 -350v450h100q0 36 7 57.5t23.5 30t29.5 10.5t40 2zM800 400h240l-240 -400h-800l300 500h500v-100z" />
+<glyph unicode="" d="M650 1100h100q21 0 35.5 -14.5t14.5 -35.5v-50h50q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-300q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5h50v50q0 21 14.5 35.5t35.5 14.5zM1000 850v150q41 0 70.5 -29.5t29.5 -70.5v-800 q0 -41 -29.5 -70.5t-70.5 -29.5h-600q-1 0 -20 4l246 246l-326 326v324q0 41 29.5 70.5t70.5 29.5v-150q0 -62 44 -106t106 -44h300q62 0 106 44t44 106zM412 250l-212 -212v162h-200v100h200v162z" />
+<glyph unicode="" d="M450 1100h100q21 0 35.5 -14.5t14.5 -35.5v-50h50q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-300q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5h50v50q0 21 14.5 35.5t35.5 14.5zM800 850v150q41 0 70.5 -29.5t29.5 -70.5v-500 h-200v-300h200q0 -36 -7 -57.5t-23.5 -30t-29.5 -10.5t-40 -2h-600q-41 0 -70.5 29.5t-29.5 70.5v800q0 41 29.5 70.5t70.5 29.5v-150q0 -62 44 -106t106 -44h300q62 0 106 44t44 106zM1212 250l-212 -212v162h-200v100h200v162z" />
+<glyph unicode="" d="M658 1197l637 -1104q23 -38 7 -65.5t-60 -27.5h-1276q-44 0 -60 27.5t7 65.5l637 1104q22 39 54 39t54 -39zM704 800h-208q-20 0 -32 -14.5t-8 -34.5l58 -302q4 -20 21.5 -34.5t37.5 -14.5h54q20 0 37.5 14.5t21.5 34.5l58 302q4 20 -8 34.5t-32 14.5zM500 300v-100h200 v100h-200z" />
+<glyph unicode="" d="M425 1100h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5zM425 800h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5 t17.5 7.5zM825 800h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5zM25 500h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v150 q0 10 7.5 17.5t17.5 7.5zM425 500h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5zM825 500h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5 v150q0 10 7.5 17.5t17.5 7.5zM25 200h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5zM425 200h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5 t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5zM825 200h250q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-250q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M700 1200h100v-200h-100v-100h350q62 0 86.5 -39.5t-3.5 -94.5l-66 -132q-41 -83 -81 -134h-772q-40 51 -81 134l-66 132q-28 55 -3.5 94.5t86.5 39.5h350v100h-100v200h100v100h200v-100zM250 400h700q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-12l137 -100 h-950l138 100h-13q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5zM50 100h1100q21 0 35.5 -14.5t14.5 -35.5v-50h-1200v50q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M600 1300q40 0 68.5 -29.5t28.5 -70.5h-194q0 41 28.5 70.5t68.5 29.5zM443 1100h314q18 -37 18 -75q0 -8 -3 -25h328q41 0 44.5 -16.5t-30.5 -38.5l-175 -145h-678l-178 145q-34 22 -29 38.5t46 16.5h328q-3 17 -3 25q0 38 18 75zM250 700h700q21 0 35.5 -14.5 t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-150v-200l275 -200h-950l275 200v200h-150q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5zM50 100h1100q21 0 35.5 -14.5t14.5 -35.5v-50h-1200v50q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M600 1181q75 0 128 -53t53 -128t-53 -128t-128 -53t-128 53t-53 128t53 128t128 53zM602 798h46q34 0 55.5 -28.5t21.5 -86.5q0 -76 39 -183h-324q39 107 39 183q0 58 21.5 86.5t56.5 28.5h45zM250 400h700q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-13 l138 -100h-950l137 100h-12q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5zM50 100h1100q21 0 35.5 -14.5t14.5 -35.5v-50h-1200v50q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M600 1300q47 0 92.5 -53.5t71 -123t25.5 -123.5q0 -78 -55.5 -133.5t-133.5 -55.5t-133.5 55.5t-55.5 133.5q0 62 34 143l144 -143l111 111l-163 163q34 26 63 26zM602 798h46q34 0 55.5 -28.5t21.5 -86.5q0 -76 39 -183h-324q39 107 39 183q0 58 21.5 86.5t56.5 28.5h45 zM250 400h700q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-13l138 -100h-950l137 100h-12q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5zM50 100h1100q21 0 35.5 -14.5t14.5 -35.5v-50h-1200v50q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M600 1200l300 -161v-139h-300q0 -57 18.5 -108t50 -91.5t63 -72t70 -67.5t57.5 -61h-530q-60 83 -90.5 177.5t-30.5 178.5t33 164.5t87.5 139.5t126 96.5t145.5 41.5v-98zM250 400h700q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-13l138 -100h-950l137 100 h-12q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5zM50 100h1100q21 0 35.5 -14.5t14.5 -35.5v-50h-1200v50q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M600 1300q41 0 70.5 -29.5t29.5 -70.5v-78q46 -26 73 -72t27 -100v-50h-400v50q0 54 27 100t73 72v78q0 41 29.5 70.5t70.5 29.5zM400 800h400q54 0 100 -27t72 -73h-172v-100h200v-100h-200v-100h200v-100h-200v-100h200q0 -83 -58.5 -141.5t-141.5 -58.5h-400 q-83 0 -141.5 58.5t-58.5 141.5v400q0 83 58.5 141.5t141.5 58.5z" />
+<glyph unicode="" d="M150 1100h900q21 0 35.5 -14.5t14.5 -35.5v-500q0 -21 -14.5 -35.5t-35.5 -14.5h-900q-21 0 -35.5 14.5t-14.5 35.5v500q0 21 14.5 35.5t35.5 14.5zM125 400h950q10 0 17.5 -7.5t7.5 -17.5v-50q0 -10 -7.5 -17.5t-17.5 -7.5h-283l224 -224q13 -13 13 -31.5t-13 -32 t-31.5 -13.5t-31.5 13l-88 88h-524l-87 -88q-13 -13 -32 -13t-32 13.5t-13 32t13 31.5l224 224h-289q-10 0 -17.5 7.5t-7.5 17.5v50q0 10 7.5 17.5t17.5 7.5zM541 300l-100 -100h324l-100 100h-124z" />
+<glyph unicode="" d="M200 1100h800q83 0 141.5 -58.5t58.5 -141.5v-200h-100q0 41 -29.5 70.5t-70.5 29.5h-250q-41 0 -70.5 -29.5t-29.5 -70.5h-100q0 41 -29.5 70.5t-70.5 29.5h-250q-41 0 -70.5 -29.5t-29.5 -70.5h-100v200q0 83 58.5 141.5t141.5 58.5zM100 600h1000q41 0 70.5 -29.5 t29.5 -70.5v-300h-1200v300q0 41 29.5 70.5t70.5 29.5zM300 100v-50q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v50h200zM1100 100v-50q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v50h200z" />
+<glyph unicode="" d="M480 1165l682 -683q31 -31 31 -75.5t-31 -75.5l-131 -131h-481l-517 518q-32 31 -32 75.5t32 75.5l295 296q31 31 75.5 31t76.5 -31zM108 794l342 -342l303 304l-341 341zM250 100h800q21 0 35.5 -14.5t14.5 -35.5v-50h-900v50q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M1057 647l-189 506q-8 19 -27.5 33t-40.5 14h-400q-21 0 -40.5 -14t-27.5 -33l-189 -506q-8 -19 1.5 -33t30.5 -14h625v-150q0 -21 14.5 -35.5t35.5 -14.5t35.5 14.5t14.5 35.5v150h125q21 0 30.5 14t1.5 33zM897 0h-595v50q0 21 14.5 35.5t35.5 14.5h50v50 q0 21 14.5 35.5t35.5 14.5h48v300h200v-300h47q21 0 35.5 -14.5t14.5 -35.5v-50h50q21 0 35.5 -14.5t14.5 -35.5v-50z" />
+<glyph unicode="" d="M900 800h300v-575q0 -10 -7.5 -17.5t-17.5 -7.5h-375v591l-300 300v84q0 10 7.5 17.5t17.5 7.5h375v-400zM1200 900h-200v200zM400 600h300v-575q0 -10 -7.5 -17.5t-17.5 -7.5h-650q-10 0 -17.5 7.5t-7.5 17.5v950q0 10 7.5 17.5t17.5 7.5h375v-400zM700 700h-200v200z " />
+<glyph unicode="" d="M484 1095h195q75 0 146 -32.5t124 -86t89.5 -122.5t48.5 -142q18 -14 35 -20q31 -10 64.5 6.5t43.5 48.5q10 34 -15 71q-19 27 -9 43q5 8 12.5 11t19 -1t23.5 -16q41 -44 39 -105q-3 -63 -46 -106.5t-104 -43.5h-62q-7 -55 -35 -117t-56 -100l-39 -234q-3 -20 -20 -34.5 t-38 -14.5h-100q-21 0 -33 14.5t-9 34.5l12 70q-49 -14 -91 -14h-195q-24 0 -65 8l-11 -64q-3 -20 -20 -34.5t-38 -14.5h-100q-21 0 -33 14.5t-9 34.5l26 157q-84 74 -128 175l-159 53q-19 7 -33 26t-14 40v50q0 21 14.5 35.5t35.5 14.5h124q11 87 56 166l-111 95 q-16 14 -12.5 23.5t24.5 9.5h203q116 101 250 101zM675 1000h-250q-10 0 -17.5 -7.5t-7.5 -17.5v-50q0 -10 7.5 -17.5t17.5 -7.5h250q10 0 17.5 7.5t7.5 17.5v50q0 10 -7.5 17.5t-17.5 7.5z" />
+<glyph unicode="" d="M641 900l423 247q19 8 42 2.5t37 -21.5l32 -38q14 -15 12.5 -36t-17.5 -34l-139 -120h-390zM50 1100h106q67 0 103 -17t66 -71l102 -212h823q21 0 35.5 -14.5t14.5 -35.5v-50q0 -21 -14 -40t-33 -26l-737 -132q-23 -4 -40 6t-26 25q-42 67 -100 67h-300q-62 0 -106 44 t-44 106v200q0 62 44 106t106 44zM173 928h-80q-19 0 -28 -14t-9 -35v-56q0 -51 42 -51h134q16 0 21.5 8t5.5 24q0 11 -16 45t-27 51q-18 28 -43 28zM550 727q-32 0 -54.5 -22.5t-22.5 -54.5t22.5 -54.5t54.5 -22.5t54.5 22.5t22.5 54.5t-22.5 54.5t-54.5 22.5zM130 389 l152 130q18 19 34 24t31 -3.5t24.5 -17.5t25.5 -28q28 -35 50.5 -51t48.5 -13l63 5l48 -179q13 -61 -3.5 -97.5t-67.5 -79.5l-80 -69q-47 -40 -109 -35.5t-103 51.5l-130 151q-40 47 -35.5 109.5t51.5 102.5zM380 377l-102 -88q-31 -27 2 -65l37 -43q13 -15 27.5 -19.5 t31.5 6.5l61 53q19 16 14 49q-2 20 -12 56t-17 45q-11 12 -19 14t-23 -8z" />
+<glyph unicode="" d="M625 1200h150q10 0 17.5 -7.5t7.5 -17.5v-109q79 -33 131 -87.5t53 -128.5q1 -46 -15 -84.5t-39 -61t-46 -38t-39 -21.5l-17 -6q6 0 15 -1.5t35 -9t50 -17.5t53 -30t50 -45t35.5 -64t14.5 -84q0 -59 -11.5 -105.5t-28.5 -76.5t-44 -51t-49.5 -31.5t-54.5 -16t-49.5 -6.5 t-43.5 -1v-75q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v75h-100v-75q0 -10 -7.5 -17.5t-17.5 -7.5h-150q-10 0 -17.5 7.5t-7.5 17.5v75h-175q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5h75v600h-75q-10 0 -17.5 7.5t-7.5 17.5v150 q0 10 7.5 17.5t17.5 7.5h175v75q0 10 7.5 17.5t17.5 7.5h150q10 0 17.5 -7.5t7.5 -17.5v-75h100v75q0 10 7.5 17.5t17.5 7.5zM400 900v-200h263q28 0 48.5 10.5t30 25t15 29t5.5 25.5l1 10q0 4 -0.5 11t-6 24t-15 30t-30 24t-48.5 11h-263zM400 500v-200h363q28 0 48.5 10.5 t30 25t15 29t5.5 25.5l1 10q0 4 -0.5 11t-6 24t-15 30t-30 24t-48.5 11h-363z" />
+<glyph unicode="" d="M212 1198h780q86 0 147 -61t61 -147v-416q0 -51 -18 -142.5t-36 -157.5l-18 -66q-29 -87 -93.5 -146.5t-146.5 -59.5h-572q-82 0 -147 59t-93 147q-8 28 -20 73t-32 143.5t-20 149.5v416q0 86 61 147t147 61zM600 1045q-70 0 -132.5 -11.5t-105.5 -30.5t-78.5 -41.5 t-57 -45t-36 -41t-20.5 -30.5l-6 -12l156 -243h560l156 243q-2 5 -6 12.5t-20 29.5t-36.5 42t-57 44.5t-79 42t-105 29.5t-132.5 12zM762 703h-157l195 261z" />
+<glyph unicode="" d="M475 1300h150q103 0 189 -86t86 -189v-500q0 -41 -42 -83t-83 -42h-450q-41 0 -83 42t-42 83v500q0 103 86 189t189 86zM700 300v-225q0 -21 -27 -48t-48 -27h-150q-21 0 -48 27t-27 48v225h300z" />
+<glyph unicode="" d="M475 1300h96q0 -150 89.5 -239.5t239.5 -89.5v-446q0 -41 -42 -83t-83 -42h-450q-41 0 -83 42t-42 83v500q0 103 86 189t189 86zM700 300v-225q0 -21 -27 -48t-48 -27h-150q-21 0 -48 27t-27 48v225h300z" />
+<glyph unicode="" d="M1294 767l-638 -283l-378 170l-78 -60v-224l100 -150v-199l-150 148l-150 -149v200l100 150v250q0 4 -0.5 10.5t0 9.5t1 8t3 8t6.5 6l47 40l-147 65l642 283zM1000 380l-350 -166l-350 166v147l350 -165l350 165v-147z" />
+<glyph unicode="" d="M250 800q62 0 106 -44t44 -106t-44 -106t-106 -44t-106 44t-44 106t44 106t106 44zM650 800q62 0 106 -44t44 -106t-44 -106t-106 -44t-106 44t-44 106t44 106t106 44zM1050 800q62 0 106 -44t44 -106t-44 -106t-106 -44t-106 44t-44 106t44 106t106 44z" />
+<glyph unicode="" d="M550 1100q62 0 106 -44t44 -106t-44 -106t-106 -44t-106 44t-44 106t44 106t106 44zM550 700q62 0 106 -44t44 -106t-44 -106t-106 -44t-106 44t-44 106t44 106t106 44zM550 300q62 0 106 -44t44 -106t-44 -106t-106 -44t-106 44t-44 106t44 106t106 44z" />
+<glyph unicode="" d="M125 1100h950q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-950q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5zM125 700h950q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-950q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5 t17.5 7.5zM125 300h950q10 0 17.5 -7.5t7.5 -17.5v-150q0 -10 -7.5 -17.5t-17.5 -7.5h-950q-10 0 -17.5 7.5t-7.5 17.5v150q0 10 7.5 17.5t17.5 7.5z" />
+<glyph unicode="" d="M350 1200h500q162 0 256 -93.5t94 -256.5v-500q0 -165 -93.5 -257.5t-256.5 -92.5h-500q-165 0 -257.5 92.5t-92.5 257.5v500q0 165 92.5 257.5t257.5 92.5zM900 1000h-600q-41 0 -70.5 -29.5t-29.5 -70.5v-600q0 -41 29.5 -70.5t70.5 -29.5h600q41 0 70.5 29.5 t29.5 70.5v600q0 41 -29.5 70.5t-70.5 29.5zM350 900h500q21 0 35.5 -14.5t14.5 -35.5v-300q0 -21 -14.5 -35.5t-35.5 -14.5h-500q-21 0 -35.5 14.5t-14.5 35.5v300q0 21 14.5 35.5t35.5 14.5zM400 800v-200h400v200h-400z" />
+<glyph unicode="" d="M150 1100h1000q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-50v-200h50q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-50v-200h50q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5t-35.5 -14.5h-50v-200h50q21 0 35.5 -14.5t14.5 -35.5t-14.5 -35.5 t-35.5 -14.5h-1000q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5h50v200h-50q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5h50v200h-50q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5h50v200h-50q-21 0 -35.5 14.5t-14.5 35.5t14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M650 1187q87 -67 118.5 -156t0 -178t-118.5 -155q-87 66 -118.5 155t0 178t118.5 156zM300 800q124 0 212 -88t88 -212q-124 0 -212 88t-88 212zM1000 800q0 -124 -88 -212t-212 -88q0 124 88 212t212 88zM300 500q124 0 212 -88t88 -212q-124 0 -212 88t-88 212z M1000 500q0 -124 -88 -212t-212 -88q0 124 88 212t212 88zM700 199v-144q0 -21 -14.5 -35.5t-35.5 -14.5t-35.5 14.5t-14.5 35.5v142q40 -4 43 -4q17 0 57 6z" />
+<glyph unicode="" d="M745 878l69 19q25 6 45 -12l298 -295q11 -11 15 -26.5t-2 -30.5q-5 -14 -18 -23.5t-28 -9.5h-8q1 0 1 -13q0 -29 -2 -56t-8.5 -62t-20 -63t-33 -53t-51 -39t-72.5 -14h-146q-184 0 -184 288q0 24 10 47q-20 4 -62 4t-63 -4q11 -24 11 -47q0 -288 -184 -288h-142 q-48 0 -84.5 21t-56 51t-32 71.5t-16 75t-3.5 68.5q0 13 2 13h-7q-15 0 -27.5 9.5t-18.5 23.5q-6 15 -2 30.5t15 25.5l298 296q20 18 46 11l76 -19q20 -5 30.5 -22.5t5.5 -37.5t-22.5 -31t-37.5 -5l-51 12l-182 -193h891l-182 193l-44 -12q-20 -5 -37.5 6t-22.5 31t6 37.5 t31 22.5z" />
+<glyph unicode="" d="M1200 900h-50q0 21 -4 37t-9.5 26.5t-18 17.5t-22 11t-28.5 5.5t-31 2t-37 0.5h-200v-850q0 -22 25 -34.5t50 -13.5l25 -2v-100h-400v100q4 0 11 0.5t24 3t30 7t24 15t11 24.5v850h-200q-25 0 -37 -0.5t-31 -2t-28.5 -5.5t-22 -11t-18 -17.5t-9.5 -26.5t-4 -37h-50v300 h1000v-300zM500 450h-25q0 15 -4 24.5t-9 14.5t-17 7.5t-20 3t-25 0.5h-100v-425q0 -11 12.5 -17.5t25.5 -7.5h12v-50h-200v50q50 0 50 25v425h-100q-17 0 -25 -0.5t-20 -3t-17 -7.5t-9 -14.5t-4 -24.5h-25v150h500v-150z" />
+<glyph unicode="" d="M1000 300v50q-25 0 -55 32q-14 14 -25 31t-16 27l-4 11l-289 747h-69l-300 -754q-18 -35 -39 -56q-9 -9 -24.5 -18.5t-26.5 -14.5l-11 -5v-50h273v50q-49 0 -78.5 21.5t-11.5 67.5l69 176h293l61 -166q13 -34 -3.5 -66.5t-55.5 -32.5v-50h312zM412 691l134 342l121 -342 h-255zM1100 150v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1000q-21 0 -35.5 14.5t-14.5 35.5v100q0 21 14.5 35.5t35.5 14.5h1000q21 0 35.5 -14.5t14.5 -35.5z" />
+<glyph unicode="" d="M50 1200h1100q21 0 35.5 -14.5t14.5 -35.5v-1100q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-21 0 -35.5 14.5t-14.5 35.5v1100q0 21 14.5 35.5t35.5 14.5zM611 1118h-70q-13 0 -18 -12l-299 -753q-17 -32 -35 -51q-18 -18 -56 -34q-12 -5 -12 -18v-50q0 -8 5.5 -14t14.5 -6 h273q8 0 14 6t6 14v50q0 8 -6 14t-14 6q-55 0 -71 23q-10 14 0 39l63 163h266l57 -153q11 -31 -6 -55q-12 -17 -36 -17q-8 0 -14 -6t-6 -14v-50q0 -8 6 -14t14 -6h313q8 0 14 6t6 14v50q0 7 -5.5 13t-13.5 7q-17 0 -42 25q-25 27 -40 63h-1l-288 748q-5 12 -19 12zM639 611 h-197l103 264z" />
+<glyph unicode="" d="M1200 1100h-1200v100h1200v-100zM50 1000h400q21 0 35.5 -14.5t14.5 -35.5v-900q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v900q0 21 14.5 35.5t35.5 14.5zM650 1000h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400 q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5zM700 900v-300h300v300h-300z" />
+<glyph unicode="" d="M50 1200h400q21 0 35.5 -14.5t14.5 -35.5v-900q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v900q0 21 14.5 35.5t35.5 14.5zM650 700h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v400 q0 21 14.5 35.5t35.5 14.5zM700 600v-300h300v300h-300zM1200 0h-1200v100h1200v-100z" />
+<glyph unicode="" d="M50 1000h400q21 0 35.5 -14.5t14.5 -35.5v-350h100v150q0 21 14.5 35.5t35.5 14.5h400q21 0 35.5 -14.5t14.5 -35.5v-150h100v-100h-100v-150q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v150h-100v-350q0 -21 -14.5 -35.5t-35.5 -14.5h-400 q-21 0 -35.5 14.5t-14.5 35.5v800q0 21 14.5 35.5t35.5 14.5zM700 700v-300h300v300h-300z" />
+<glyph unicode="" d="M100 0h-100v1200h100v-1200zM250 1100h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5zM300 1000v-300h300v300h-300zM250 500h900q21 0 35.5 -14.5t14.5 -35.5v-400 q0 -21 -14.5 -35.5t-35.5 -14.5h-900q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M600 1100h150q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-150v-100h450q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-900q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5h350v100h-150q-21 0 -35.5 14.5 t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5h150v100h100v-100zM400 1000v-300h300v300h-300z" />
+<glyph unicode="" d="M1200 0h-100v1200h100v-1200zM550 1100h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5zM600 1000v-300h300v300h-300zM50 500h900q21 0 35.5 -14.5t14.5 -35.5v-400 q0 -21 -14.5 -35.5t-35.5 -14.5h-900q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5z" />
+<glyph unicode="" d="M865 565l-494 -494q-23 -23 -41 -23q-14 0 -22 13.5t-8 38.5v1000q0 25 8 38.5t22 13.5q18 0 41 -23l494 -494q14 -14 14 -35t-14 -35z" />
+<glyph unicode="" d="M335 635l494 494q29 29 50 20.5t21 -49.5v-1000q0 -41 -21 -49.5t-50 20.5l-494 494q-14 14 -14 35t14 35z" />
+<glyph unicode="" d="M100 900h1000q41 0 49.5 -21t-20.5 -50l-494 -494q-14 -14 -35 -14t-35 14l-494 494q-29 29 -20.5 50t49.5 21z" />
+<glyph unicode="" d="M635 865l494 -494q29 -29 20.5 -50t-49.5 -21h-1000q-41 0 -49.5 21t20.5 50l494 494q14 14 35 14t35 -14z" />
+<glyph unicode="" d="M700 741v-182l-692 -323v221l413 193l-413 193v221zM1200 0h-800v200h800v-200z" />
+<glyph unicode="" d="M1200 900h-200v-100h200v-100h-300v300h200v100h-200v100h300v-300zM0 700h50q0 21 4 37t9.5 26.5t18 17.5t22 11t28.5 5.5t31 2t37 0.5h100v-550q0 -22 -25 -34.5t-50 -13.5l-25 -2v-100h400v100q-4 0 -11 0.5t-24 3t-30 7t-24 15t-11 24.5v550h100q25 0 37 -0.5t31 -2 t28.5 -5.5t22 -11t18 -17.5t9.5 -26.5t4 -37h50v300h-800v-300z" />
+<glyph unicode="" d="M800 700h-50q0 21 -4 37t-9.5 26.5t-18 17.5t-22 11t-28.5 5.5t-31 2t-37 0.5h-100v-550q0 -22 25 -34.5t50 -14.5l25 -1v-100h-400v100q4 0 11 0.5t24 3t30 7t24 15t11 24.5v550h-100q-25 0 -37 -0.5t-31 -2t-28.5 -5.5t-22 -11t-18 -17.5t-9.5 -26.5t-4 -37h-50v300 h800v-300zM1100 200h-200v-100h200v-100h-300v300h200v100h-200v100h300v-300z" />
+<glyph unicode="" d="M701 1098h160q16 0 21 -11t-7 -23l-464 -464l464 -464q12 -12 7 -23t-21 -11h-160q-13 0 -23 9l-471 471q-7 8 -7 18t7 18l471 471q10 9 23 9z" />
+<glyph unicode="" d="M339 1098h160q13 0 23 -9l471 -471q7 -8 7 -18t-7 -18l-471 -471q-10 -9 -23 -9h-160q-16 0 -21 11t7 23l464 464l-464 464q-12 12 -7 23t21 11z" />
+<glyph unicode="" d="M1087 882q11 -5 11 -21v-160q0 -13 -9 -23l-471 -471q-8 -7 -18 -7t-18 7l-471 471q-9 10 -9 23v160q0 16 11 21t23 -7l464 -464l464 464q12 12 23 7z" />
+<glyph unicode="" d="M618 993l471 -471q9 -10 9 -23v-160q0 -16 -11 -21t-23 7l-464 464l-464 -464q-12 -12 -23 -7t-11 21v160q0 13 9 23l471 471q8 7 18 7t18 -7z" />
+<glyph unicode="" d="M1000 1200q0 -124 -88 -212t-212 -88q0 124 88 212t212 88zM450 1000h100q21 0 40 -14t26 -33l79 -194q5 1 16 3q34 6 54 9.5t60 7t65.5 1t61 -10t56.5 -23t42.5 -42t29 -64t5 -92t-19.5 -121.5q-1 -7 -3 -19.5t-11 -50t-20.5 -73t-32.5 -81.5t-46.5 -83t-64 -70 t-82.5 -50q-13 -5 -42 -5t-65.5 2.5t-47.5 2.5q-14 0 -49.5 -3.5t-63 -3.5t-43.5 7q-57 25 -104.5 78.5t-75 111.5t-46.5 112t-26 90l-7 35q-15 63 -18 115t4.5 88.5t26 64t39.5 43.5t52 25.5t58.5 13t62.5 2t59.5 -4.5t55.5 -8l-147 192q-12 18 -5.5 30t27.5 12z" />
+<glyph unicode="🔑" d="M250 1200h600q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-150v-500l-255 -178q-19 -9 -32 -1t-13 29v650h-150q-21 0 -35.5 14.5t-14.5 35.5v400q0 21 14.5 35.5t35.5 14.5zM400 1100v-100h300v100h-300z" />
+<glyph unicode="🚪" d="M250 1200h750q39 0 69.5 -40.5t30.5 -84.5v-933l-700 -117v950l600 125h-700v-1000h-100v1025q0 23 15.5 49t34.5 26zM500 525v-100l100 20v100z" />
+</font>
+</defs></svg>
\ No newline at end of file
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.ttf b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.ttf
new file mode 100644
index 0000000..1413fc6
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.ttf
Binary files differ
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.woff b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.woff
new file mode 100644
index 0000000..9e61285
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.woff
Binary files differ
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.woff2 b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.woff2
new file mode 100644
index 0000000..64539b5
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/fonts/glyphicons-halflings-regular.woff2
Binary files differ
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo.png b/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo.png
new file mode 100644
index 0000000..e962ce0
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo.png
Binary files differ
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo_med.gif b/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo_med.gif
new file mode 100644
index 0000000..36d3e3c
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo_med.gif
Binary files differ
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo_small.png b/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo_small.png
new file mode 100644
index 0000000..8c6353a
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/hbase_logo_small.png
Binary files differ
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/js/bootstrap.min.js b/hbase-thrift/src/main/resources/hbase-webapps/static/js/bootstrap.min.js
new file mode 100644
index 0000000..eb0a8b4
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/js/bootstrap.min.js
@@ -0,0 +1,6 @@
+/*!
+ * Bootstrap v3.4.1 (https://getbootstrap.com/)
+ * Copyright 2011-2019 Twitter, Inc.
+ * Licensed under the MIT license
+ */
+if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(t){"use strict";var e=jQuery.fn.jquery.split(" ")[0].split(".");if(e[0]<2&&e[1]<9||1==e[0]&&9==e[1]&&e[2]<1||3<e[0])throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(),function(n){"use strict";n.fn.emulateTransitionEnd=function(t){var e=!1,i=this;n(this).one("bsTransitionEnd",function(){e=!0});return setTimeout(function(){e||n(i).trigger(n.support.transition.end)},t),this},n(function(){n.support.transition=function o(){var t=document.createElement("bootstrap"),e={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var i in e)if(t.style[i]!==undefined)return{end:e[i]};return!1}(),n.support.transition&&(n.event.special.bsTransitionEnd={bindType:n.support.transition.end,delegateType:n.support.transition.end,handle:function(t){if(n(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})})}(jQuery),function(s){"use strict";var e='[data-dismiss="alert"]',a=function(t){s(t).on("click",e,this.close)};a.VERSION="3.4.1",a.TRANSITION_DURATION=150,a.prototype.close=function(t){var e=s(this),i=e.attr("data-target");i||(i=(i=e.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=s(document).find(i);function n(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=e.closest(".alert")),o.trigger(t=s.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),s.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",n).emulateTransitionEnd(a.TRANSITION_DURATION):n())};var t=s.fn.alert;s.fn.alert=function o(i){return this.each(function(){var t=s(this),e=t.data("bs.alert");e||t.data("bs.alert",e=new a(this)),"string"==typeof i&&e[i].call(t)})},s.fn.alert.Constructor=a,s.fn.alert.noConflict=function(){return s.fn.alert=t,this},s(document).on("click.bs.alert.data-api",e,a.prototype.close)}(jQuery),function(s){"use strict";var n=function(t,e){this.$element=s(t),this.options=s.extend({},n.DEFAULTS,e),this.isLoading=!1};function i(o){return this.each(function(){var t=s(this),e=t.data("bs.button"),i="object"==typeof o&&o;e||t.data("bs.button",e=new n(this,i)),"toggle"==o?e.toggle():o&&e.setState(o)})}n.VERSION="3.4.1",n.DEFAULTS={loadingText:"loading..."},n.prototype.setState=function(t){var e="disabled",i=this.$element,o=i.is("input")?"val":"html",n=i.data();t+="Text",null==n.resetText&&i.data("resetText",i[o]()),setTimeout(s.proxy(function(){i[o](null==n[t]?this.options[t]:n[t]),"loadingText"==t?(this.isLoading=!0,i.addClass(e).attr(e,e).prop(e,!0)):this.isLoading&&(this.isLoading=!1,i.removeClass(e).removeAttr(e).prop(e,!1))},this),0)},n.prototype.toggle=function(){var t=!0,e=this.$element.closest('[data-toggle="buttons"]');if(e.length){var i=this.$element.find("input");"radio"==i.prop("type")?(i.prop("checked")&&(t=!1),e.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==i.prop("type")&&(i.prop("checked")!==this.$element.hasClass("active")&&(t=!1),this.$element.toggleClass("active")),i.prop("checked",this.$element.hasClass("active")),t&&i.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var t=s.fn.button;s.fn.button=i,s.fn.button.Constructor=n,s.fn.button.noConflict=function(){return s.fn.button=t,this},s(document).on("click.bs.button.data-api",'[data-toggle^="button"]',function(t){var e=s(t.target).closest(".btn");i.call(e,"toggle"),s(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),e.is("input,button")?e.trigger("focus"):e.find("input:visible,button:visible").first().trigger("focus"))}).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',function(t){s(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))})}(jQuery),function(p){"use strict";var c=function(t,e){this.$element=p(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=e,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",p.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",p.proxy(this.pause,this)).on("mouseleave.bs.carousel",p.proxy(this.cycle,this))};function r(n){return this.each(function(){var t=p(this),e=t.data("bs.carousel"),i=p.extend({},c.DEFAULTS,t.data(),"object"==typeof n&&n),o="string"==typeof n?n:i.slide;e||t.data("bs.carousel",e=new c(this,i)),"number"==typeof n?e.to(n):o?e[o]():i.interval&&e.pause().cycle()})}c.VERSION="3.4.1",c.TRANSITION_DURATION=600,c.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},c.prototype.keydown=function(t){if(!/input|textarea/i.test(t.target.tagName)){switch(t.which){case 37:this.prev();break;case 39:this.next();break;default:return}t.preventDefault()}},c.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(p.proxy(this.next,this),this.options.interval)),this},c.prototype.getItemIndex=function(t){return this.$items=t.parent().children(".item"),this.$items.index(t||this.$active)},c.prototype.getItemForDirection=function(t,e){var i=this.getItemIndex(e);if(("prev"==t&&0===i||"next"==t&&i==this.$items.length-1)&&!this.options.wrap)return e;var o=(i+("prev"==t?-1:1))%this.$items.length;return this.$items.eq(o)},c.prototype.to=function(t){var e=this,i=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(t>this.$items.length-1||t<0))return this.sliding?this.$element.one("slid.bs.carousel",function(){e.to(t)}):i==t?this.pause().cycle():this.slide(i<t?"next":"prev",this.$items.eq(t))},c.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&p.support.transition&&(this.$element.trigger(p.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},c.prototype.next=function(){if(!this.sliding)return this.slide("next")},c.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},c.prototype.slide=function(t,e){var i=this.$element.find(".item.active"),o=e||this.getItemForDirection(t,i),n=this.interval,s="next"==t?"left":"right",a=this;if(o.hasClass("active"))return this.sliding=!1;var r=o[0],l=p.Event("slide.bs.carousel",{relatedTarget:r,direction:s});if(this.$element.trigger(l),!l.isDefaultPrevented()){if(this.sliding=!0,n&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var h=p(this.$indicators.children()[this.getItemIndex(o)]);h&&h.addClass("active")}var d=p.Event("slid.bs.carousel",{relatedTarget:r,direction:s});return p.support.transition&&this.$element.hasClass("slide")?(o.addClass(t),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(s),o.addClass(s),i.one("bsTransitionEnd",function(){o.removeClass([t,s].join(" ")).addClass("active"),i.removeClass(["active",s].join(" ")),a.sliding=!1,setTimeout(function(){a.$element.trigger(d)},0)}).emulateTransitionEnd(c.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(d)),n&&this.cycle(),this}};var t=p.fn.carousel;p.fn.carousel=r,p.fn.carousel.Constructor=c,p.fn.carousel.noConflict=function(){return p.fn.carousel=t,this};var e=function(t){var e=p(this),i=e.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=e.attr("data-target")||i,n=p(document).find(o);if(n.hasClass("carousel")){var s=p.extend({},n.data(),e.data()),a=e.attr("data-slide-to");a&&(s.interval=!1),r.call(n,s),a&&n.data("bs.carousel").to(a),t.preventDefault()}};p(document).on("click.bs.carousel.data-api","[data-slide]",e).on("click.bs.carousel.data-api","[data-slide-to]",e),p(window).on("load",function(){p('[data-ride="carousel"]').each(function(){var t=p(this);r.call(t,t.data())})})}(jQuery),function(a){"use strict";var r=function(t,e){this.$element=a(t),this.options=a.extend({},r.DEFAULTS,e),this.$trigger=a('[data-toggle="collapse"][href="#'+t.id+'"],[data-toggle="collapse"][data-target="#'+t.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(t){var e,i=t.attr("data-target")||(e=t.attr("href"))&&e.replace(/.*(?=#[^\s]+$)/,"");return a(document).find(i)}function l(o){return this.each(function(){var t=a(this),e=t.data("bs.collapse"),i=a.extend({},r.DEFAULTS,t.data(),"object"==typeof o&&o);!e&&i.toggle&&/show|hide/.test(o)&&(i.toggle=!1),e||t.data("bs.collapse",e=new r(this,i)),"string"==typeof o&&e[o]()})}r.VERSION="3.4.1",r.TRANSITION_DURATION=350,r.DEFAULTS={toggle:!0},r.prototype.dimension=function(){return this.$element.hasClass("width")?"width":"height"},r.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var t,e=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(e&&e.length&&(t=e.data("bs.collapse"))&&t.transitioning)){var i=a.Event("show.bs.collapse");if(this.$element.trigger(i),!i.isDefaultPrevented()){e&&e.length&&(l.call(e,"hide"),t||e.data("bs.collapse",null));var o=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[o](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var n=function(){this.$element.removeClass("collapsing").addClass("collapse in")[o](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!a.support.transition)return n.call(this);var s=a.camelCase(["scroll",o].join("-"));this.$element.one("bsTransitionEnd",a.proxy(n,this)).emulateTransitionEnd(r.TRANSITION_DURATION)[o](this.$element[0][s])}}}},r.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var t=a.Event("hide.bs.collapse");if(this.$element.trigger(t),!t.isDefaultPrevented()){var e=this.dimension();this.$element[e](this.$element[e]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!a.support.transition)return i.call(this);this.$element[e](0).one("bsTransitionEnd",a.proxy(i,this)).emulateTransitionEnd(r.TRANSITION_DURATION)}}},r.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},r.prototype.getParent=function(){return a(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(a.proxy(function(t,e){var i=a(e);this.addAriaAndCollapsedClass(n(i),i)},this)).end()},r.prototype.addAriaAndCollapsedClass=function(t,e){var i=t.hasClass("in");t.attr("aria-expanded",i),e.toggleClass("collapsed",!i).attr("aria-expanded",i)};var t=a.fn.collapse;a.fn.collapse=l,a.fn.collapse.Constructor=r,a.fn.collapse.noConflict=function(){return a.fn.collapse=t,this},a(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',function(t){var e=a(this);e.attr("data-target")||t.preventDefault();var i=n(e),o=i.data("bs.collapse")?"toggle":e.data();l.call(i,o)})}(jQuery),function(a){"use strict";var r='[data-toggle="dropdown"]',o=function(t){a(t).on("click.bs.dropdown",this.toggle)};function l(t){var e=t.attr("data-target");e||(e=(e=t.attr("href"))&&/#[A-Za-z]/.test(e)&&e.replace(/.*(?=#[^\s]*$)/,""));var i="#"!==e?a(document).find(e):null;return i&&i.length?i:t.parent()}function s(o){o&&3===o.which||(a(".dropdown-backdrop").remove(),a(r).each(function(){var t=a(this),e=l(t),i={relatedTarget:this};e.hasClass("open")&&(o&&"click"==o.type&&/input|textarea/i.test(o.target.tagName)&&a.contains(e[0],o.target)||(e.trigger(o=a.Event("hide.bs.dropdown",i)),o.isDefaultPrevented()||(t.attr("aria-expanded","false"),e.removeClass("open").trigger(a.Event("hidden.bs.dropdown",i)))))}))}o.VERSION="3.4.1",o.prototype.toggle=function(t){var e=a(this);if(!e.is(".disabled, :disabled")){var i=l(e),o=i.hasClass("open");if(s(),!o){"ontouchstart"in document.documentElement&&!i.closest(".navbar-nav").length&&a(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(a(this)).on("click",s);var n={relatedTarget:this};if(i.trigger(t=a.Event("show.bs.dropdown",n)),t.isDefaultPrevented())return;e.trigger("focus").attr("aria-expanded","true"),i.toggleClass("open").trigger(a.Event("shown.bs.dropdown",n))}return!1}},o.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var e=a(this);if(t.preventDefault(),t.stopPropagation(),!e.is(".disabled, :disabled")){var i=l(e),o=i.hasClass("open");if(!o&&27!=t.which||o&&27==t.which)return 27==t.which&&i.find(r).trigger("focus"),e.trigger("click");var n=i.find(".dropdown-menu li:not(.disabled):visible a");if(n.length){var s=n.index(t.target);38==t.which&&0<s&&s--,40==t.which&&s<n.length-1&&s++,~s||(s=0),n.eq(s).trigger("focus")}}}};var t=a.fn.dropdown;a.fn.dropdown=function e(i){return this.each(function(){var t=a(this),e=t.data("bs.dropdown");e||t.data("bs.dropdown",e=new o(this)),"string"==typeof i&&e[i].call(t)})},a.fn.dropdown.Constructor=o,a.fn.dropdown.noConflict=function(){return a.fn.dropdown=t,this},a(document).on("click.bs.dropdown.data-api",s).on("click.bs.dropdown.data-api",".dropdown form",function(t){t.stopPropagation()}).on("click.bs.dropdown.data-api",r,o.prototype.toggle).on("keydown.bs.dropdown.data-api",r,o.prototype.keydown).on("keydown.bs.dropdown.data-api",".dropdown-menu",o.prototype.keydown)}(jQuery),function(a){"use strict";var s=function(t,e){this.options=e,this.$body=a(document.body),this.$element=a(t),this.$dialog=this.$element.find(".modal-dialog"),this.$backdrop=null,this.isShown=null,this.originalBodyPad=null,this.scrollbarWidth=0,this.ignoreBackdropClick=!1,this.fixedContent=".navbar-fixed-top, .navbar-fixed-bottom",this.options.remote&&this.$element.find(".modal-content").load(this.options.remote,a.proxy(function(){this.$element.trigger("loaded.bs.modal")},this))};function r(o,n){return this.each(function(){var t=a(this),e=t.data("bs.modal"),i=a.extend({},s.DEFAULTS,t.data(),"object"==typeof o&&o);e||t.data("bs.modal",e=new s(this,i)),"string"==typeof o?e[o](n):i.show&&e.show(n)})}s.VERSION="3.4.1",s.TRANSITION_DURATION=300,s.BACKDROP_TRANSITION_DURATION=150,s.DEFAULTS={backdrop:!0,keyboard:!0,show:!0},s.prototype.toggle=function(t){return this.isShown?this.hide():this.show(t)},s.prototype.show=function(i){var o=this,t=a.Event("show.bs.modal",{relatedTarget:i});this.$element.trigger(t),this.isShown||t.isDefaultPrevented()||(this.isShown=!0,this.checkScrollbar(),this.setScrollbar(),this.$body.addClass("modal-open"),this.escape(),this.resize(),this.$element.on("click.dismiss.bs.modal",'[data-dismiss="modal"]',a.proxy(this.hide,this)),this.$dialog.on("mousedown.dismiss.bs.modal",function(){o.$element.one("mouseup.dismiss.bs.modal",function(t){a(t.target).is(o.$element)&&(o.ignoreBackdropClick=!0)})}),this.backdrop(function(){var t=a.support.transition&&o.$element.hasClass("fade");o.$element.parent().length||o.$element.appendTo(o.$body),o.$element.show().scrollTop(0),o.adjustDialog(),t&&o.$element[0].offsetWidth,o.$element.addClass("in"),o.enforceFocus();var e=a.Event("shown.bs.modal",{relatedTarget:i});t?o.$dialog.one("bsTransitionEnd",function(){o.$element.trigger("focus").trigger(e)}).emulateTransitionEnd(s.TRANSITION_DURATION):o.$element.trigger("focus").trigger(e)}))},s.prototype.hide=function(t){t&&t.preventDefault(),t=a.Event("hide.bs.modal"),this.$element.trigger(t),this.isShown&&!t.isDefaultPrevented()&&(this.isShown=!1,this.escape(),this.resize(),a(document).off("focusin.bs.modal"),this.$element.removeClass("in").off("click.dismiss.bs.modal").off("mouseup.dismiss.bs.modal"),this.$dialog.off("mousedown.dismiss.bs.modal"),a.support.transition&&this.$element.hasClass("fade")?this.$element.one("bsTransitionEnd",a.proxy(this.hideModal,this)).emulateTransitionEnd(s.TRANSITION_DURATION):this.hideModal())},s.prototype.enforceFocus=function(){a(document).off("focusin.bs.modal").on("focusin.bs.modal",a.proxy(function(t){document===t.target||this.$element[0]===t.target||this.$element.has(t.target).length||this.$element.trigger("focus")},this))},s.prototype.escape=function(){this.isShown&&this.options.keyboard?this.$element.on("keydown.dismiss.bs.modal",a.proxy(function(t){27==t.which&&this.hide()},this)):this.isShown||this.$element.off("keydown.dismiss.bs.modal")},s.prototype.resize=function(){this.isShown?a(window).on("resize.bs.modal",a.proxy(this.handleUpdate,this)):a(window).off("resize.bs.modal")},s.prototype.hideModal=function(){var t=this;this.$element.hide(),this.backdrop(function(){t.$body.removeClass("modal-open"),t.resetAdjustments(),t.resetScrollbar(),t.$element.trigger("hidden.bs.modal")})},s.prototype.removeBackdrop=function(){this.$backdrop&&this.$backdrop.remove(),this.$backdrop=null},s.prototype.backdrop=function(t){var e=this,i=this.$element.hasClass("fade")?"fade":"";if(this.isShown&&this.options.backdrop){var o=a.support.transition&&i;if(this.$backdrop=a(document.createElement("div")).addClass("modal-backdrop "+i).appendTo(this.$body),this.$element.on("click.dismiss.bs.modal",a.proxy(function(t){this.ignoreBackdropClick?this.ignoreBackdropClick=!1:t.target===t.currentTarget&&("static"==this.options.backdrop?this.$element[0].focus():this.hide())},this)),o&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),!t)return;o?this.$backdrop.one("bsTransitionEnd",t).emulateTransitionEnd(s.BACKDROP_TRANSITION_DURATION):t()}else if(!this.isShown&&this.$backdrop){this.$backdrop.removeClass("in");var n=function(){e.removeBackdrop(),t&&t()};a.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one("bsTransitionEnd",n).emulateTransitionEnd(s.BACKDROP_TRANSITION_DURATION):n()}else t&&t()},s.prototype.handleUpdate=function(){this.adjustDialog()},s.prototype.adjustDialog=function(){var t=this.$element[0].scrollHeight>document.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&t?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!t?this.scrollbarWidth:""})},s.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},s.prototype.checkScrollbar=function(){var t=window.innerWidth;if(!t){var e=document.documentElement.getBoundingClientRect();t=e.right-Math.abs(e.left)}this.bodyIsOverflowing=document.body.clientWidth<t,this.scrollbarWidth=this.measureScrollbar()},s.prototype.setScrollbar=function(){var t=parseInt(this.$body.css("padding-right")||0,10);this.originalBodyPad=document.body.style.paddingRight||"";var n=this.scrollbarWidth;this.bodyIsOverflowing&&(this.$body.css("padding-right",t+n),a(this.fixedContent).each(function(t,e){var i=e.style.paddingRight,o=a(e).css("padding-right");a(e).data("padding-right",i).css("padding-right",parseFloat(o)+n+"px")}))},s.prototype.resetScrollbar=function(){this.$body.css("padding-right",this.originalBodyPad),a(this.fixedContent).each(function(t,e){var i=a(e).data("padding-right");a(e).removeData("padding-right"),e.style.paddingRight=i||""})},s.prototype.measureScrollbar=function(){var t=document.createElement("div");t.className="modal-scrollbar-measure",this.$body.append(t);var e=t.offsetWidth-t.clientWidth;return this.$body[0].removeChild(t),e};var t=a.fn.modal;a.fn.modal=r,a.fn.modal.Constructor=s,a.fn.modal.noConflict=function(){return a.fn.modal=t,this},a(document).on("click.bs.modal.data-api",'[data-toggle="modal"]',function(t){var e=a(this),i=e.attr("href"),o=e.attr("data-target")||i&&i.replace(/.*(?=#[^\s]+$)/,""),n=a(document).find(o),s=n.data("bs.modal")?"toggle":a.extend({remote:!/#/.test(i)&&i},n.data(),e.data());e.is("a")&&t.preventDefault(),n.one("show.bs.modal",function(t){t.isDefaultPrevented()||n.one("hidden.bs.modal",function(){e.is(":visible")&&e.trigger("focus")})}),r.call(n,s,this)})}(jQuery),function(g){"use strict";var o=["sanitize","whiteList","sanitizeFn"],a=["background","cite","href","itemtype","longdesc","poster","src","xlink:href"],t={"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},r=/^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi,l=/^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i;function u(t,e){var i=t.nodeName.toLowerCase();if(-1!==g.inArray(i,e))return-1===g.inArray(i,a)||Boolean(t.nodeValue.match(r)||t.nodeValue.match(l));for(var o=g(e).filter(function(t,e){return e instanceof RegExp}),n=0,s=o.length;n<s;n++)if(i.match(o[n]))return!0;return!1}function n(t,e,i){if(0===t.length)return t;if(i&&"function"==typeof i)return i(t);if(!document.implementation||!document.implementation.createHTMLDocument)return t;var o=document.implementation.createHTMLDocument("sanitization");o.body.innerHTML=t;for(var n=g.map(e,function(t,e){return e}),s=g(o.body).find("*"),a=0,r=s.length;a<r;a++){var l=s[a],h=l.nodeName.toLowerCase();if(-1!==g.inArray(h,n))for(var d=g.map(l.attributes,function(t){return t}),p=[].concat(e["*"]||[],e[h]||[]),c=0,f=d.length;c<f;c++)u(d[c],p)||l.removeAttribute(d[c].nodeName);else l.parentNode.removeChild(l)}return o.body.innerHTML}var m=function(t,e){this.type=null,this.options=null,this.enabled=null,this.timeout=null,this.hoverState=null,this.$element=null,this.inState=null,this.init("tooltip",t,e)};m.VERSION="3.4.1",m.TRANSITION_DURATION=150,m.DEFAULTS={animation:!0,placement:"top",selector:!1,template:'<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:t},m.prototype.init=function(t,e,i){if(this.enabled=!0,this.type=t,this.$element=g(e),this.options=this.getOptions(i),this.$viewport=this.options.viewport&&g(document).find(g.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var o=this.options.trigger.split(" "),n=o.length;n--;){var s=o[n];if("click"==s)this.$element.on("click."+this.type,this.options.selector,g.proxy(this.toggle,this));else if("manual"!=s){var a="hover"==s?"mouseenter":"focusin",r="hover"==s?"mouseleave":"focusout";this.$element.on(a+"."+this.type,this.options.selector,g.proxy(this.enter,this)),this.$element.on(r+"."+this.type,this.options.selector,g.proxy(this.leave,this))}}this.options.selector?this._options=g.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},m.prototype.getDefaults=function(){return m.DEFAULTS},m.prototype.getOptions=function(t){var e=this.$element.data();for(var i in e)e.hasOwnProperty(i)&&-1!==g.inArray(i,o)&&delete e[i];return(t=g.extend({},this.getDefaults(),e,t)).delay&&"number"==typeof t.delay&&(t.delay={show:t.delay,hide:t.delay}),t.sanitize&&(t.template=n(t.template,t.whiteList,t.sanitizeFn)),t},m.prototype.getDelegateOptions=function(){var i={},o=this.getDefaults();return this._options&&g.each(this._options,function(t,e){o[t]!=e&&(i[t]=e)}),i},m.prototype.enter=function(t){var e=t instanceof this.constructor?t:g(t.currentTarget).data("bs."+this.type);if(e||(e=new this.constructor(t.currentTarget,this.getDelegateOptions()),g(t.currentTarget).data("bs."+this.type,e)),t instanceof g.Event&&(e.inState["focusin"==t.type?"focus":"hover"]=!0),e.tip().hasClass("in")||"in"==e.hoverState)e.hoverState="in";else{if(clearTimeout(e.timeout),e.hoverState="in",!e.options.delay||!e.options.delay.show)return e.show();e.timeout=setTimeout(function(){"in"==e.hoverState&&e.show()},e.options.delay.show)}},m.prototype.isInStateTrue=function(){for(var t in this.inState)if(this.inState[t])return!0;return!1},m.prototype.leave=function(t){var e=t instanceof this.constructor?t:g(t.currentTarget).data("bs."+this.type);if(e||(e=new this.constructor(t.currentTarget,this.getDelegateOptions()),g(t.currentTarget).data("bs."+this.type,e)),t instanceof g.Event&&(e.inState["focusout"==t.type?"focus":"hover"]=!1),!e.isInStateTrue()){if(clearTimeout(e.timeout),e.hoverState="out",!e.options.delay||!e.options.delay.hide)return e.hide();e.timeout=setTimeout(function(){"out"==e.hoverState&&e.hide()},e.options.delay.hide)}},m.prototype.show=function(){var t=g.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var e=g.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!e)return;var i=this,o=this.tip(),n=this.getUID(this.type);this.setContent(),o.attr("id",n),this.$element.attr("aria-describedby",n),this.options.animation&&o.addClass("fade");var s="function"==typeof this.options.placement?this.options.placement.call(this,o[0],this.$element[0]):this.options.placement,a=/\s?auto?\s?/i,r=a.test(s);r&&(s=s.replace(a,"")||"top"),o.detach().css({top:0,left:0,display:"block"}).addClass(s).data("bs."+this.type,this),this.options.container?o.appendTo(g(document).find(this.options.container)):o.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var l=this.getPosition(),h=o[0].offsetWidth,d=o[0].offsetHeight;if(r){var p=s,c=this.getPosition(this.$viewport);s="bottom"==s&&l.bottom+d>c.bottom?"top":"top"==s&&l.top-d<c.top?"bottom":"right"==s&&l.right+h>c.width?"left":"left"==s&&l.left-h<c.left?"right":s,o.removeClass(p).addClass(s)}var f=this.getCalculatedOffset(s,l,h,d);this.applyPlacement(f,s);var u=function(){var t=i.hoverState;i.$element.trigger("shown.bs."+i.type),i.hoverState=null,"out"==t&&i.leave(i)};g.support.transition&&this.$tip.hasClass("fade")?o.one("bsTransitionEnd",u).emulateTransitionEnd(m.TRANSITION_DURATION):u()}},m.prototype.applyPlacement=function(t,e){var i=this.tip(),o=i[0].offsetWidth,n=i[0].offsetHeight,s=parseInt(i.css("margin-top"),10),a=parseInt(i.css("margin-left"),10);isNaN(s)&&(s=0),isNaN(a)&&(a=0),t.top+=s,t.left+=a,g.offset.setOffset(i[0],g.extend({using:function(t){i.css({top:Math.round(t.top),left:Math.round(t.left)})}},t),0),i.addClass("in");var r=i[0].offsetWidth,l=i[0].offsetHeight;"top"==e&&l!=n&&(t.top=t.top+n-l);var h=this.getViewportAdjustedDelta(e,t,r,l);h.left?t.left+=h.left:t.top+=h.top;var d=/top|bottom/.test(e),p=d?2*h.left-o+r:2*h.top-n+l,c=d?"offsetWidth":"offsetHeight";i.offset(t),this.replaceArrow(p,i[0][c],d)},m.prototype.replaceArrow=function(t,e,i){this.arrow().css(i?"left":"top",50*(1-t/e)+"%").css(i?"top":"left","")},m.prototype.setContent=function(){var t=this.tip(),e=this.getTitle();this.options.html?(this.options.sanitize&&(e=n(e,this.options.whiteList,this.options.sanitizeFn)),t.find(".tooltip-inner").html(e)):t.find(".tooltip-inner").text(e),t.removeClass("fade in top bottom left right")},m.prototype.hide=function(t){var e=this,i=g(this.$tip),o=g.Event("hide.bs."+this.type);function n(){"in"!=e.hoverState&&i.detach(),e.$element&&e.$element.removeAttr("aria-describedby").trigger("hidden.bs."+e.type),t&&t()}if(this.$element.trigger(o),!o.isDefaultPrevented())return i.removeClass("in"),g.support.transition&&i.hasClass("fade")?i.one("bsTransitionEnd",n).emulateTransitionEnd(m.TRANSITION_DURATION):n(),this.hoverState=null,this},m.prototype.fixTitle=function(){var t=this.$element;(t.attr("title")||"string"!=typeof t.attr("data-original-title"))&&t.attr("data-original-title",t.attr("title")||"").attr("title","")},m.prototype.hasContent=function(){return this.getTitle()},m.prototype.getPosition=function(t){var e=(t=t||this.$element)[0],i="BODY"==e.tagName,o=e.getBoundingClientRect();null==o.width&&(o=g.extend({},o,{width:o.right-o.left,height:o.bottom-o.top}));var n=window.SVGElement&&e instanceof window.SVGElement,s=i?{top:0,left:0}:n?null:t.offset(),a={scroll:i?document.documentElement.scrollTop||document.body.scrollTop:t.scrollTop()},r=i?{width:g(window).width(),height:g(window).height()}:null;return g.extend({},o,a,r,s)},m.prototype.getCalculatedOffset=function(t,e,i,o){return"bottom"==t?{top:e.top+e.height,left:e.left+e.width/2-i/2}:"top"==t?{top:e.top-o,left:e.left+e.width/2-i/2}:"left"==t?{top:e.top+e.height/2-o/2,left:e.left-i}:{top:e.top+e.height/2-o/2,left:e.left+e.width}},m.prototype.getViewportAdjustedDelta=function(t,e,i,o){var n={top:0,left:0};if(!this.$viewport)return n;var s=this.options.viewport&&this.options.viewport.padding||0,a=this.getPosition(this.$viewport);if(/right|left/.test(t)){var r=e.top-s-a.scroll,l=e.top+s-a.scroll+o;r<a.top?n.top=a.top-r:l>a.top+a.height&&(n.top=a.top+a.height-l)}else{var h=e.left-s,d=e.left+s+i;h<a.left?n.left=a.left-h:d>a.right&&(n.left=a.left+a.width-d)}return n},m.prototype.getTitle=function(){var t=this.$element,e=this.options;return t.attr("data-original-title")||("function"==typeof e.title?e.title.call(t[0]):e.title)},m.prototype.getUID=function(t){for(;t+=~~(1e6*Math.random()),document.getElementById(t););return t},m.prototype.tip=function(){if(!this.$tip&&(this.$tip=g(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},m.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},m.prototype.enable=function(){this.enabled=!0},m.prototype.disable=function(){this.enabled=!1},m.prototype.toggleEnabled=function(){this.enabled=!this.enabled},m.prototype.toggle=function(t){var e=this;t&&((e=g(t.currentTarget).data("bs."+this.type))||(e=new this.constructor(t.currentTarget,this.getDelegateOptions()),g(t.currentTarget).data("bs."+this.type,e))),t?(e.inState.click=!e.inState.click,e.isInStateTrue()?e.enter(e):e.leave(e)):e.tip().hasClass("in")?e.leave(e):e.enter(e)},m.prototype.destroy=function(){var t=this;clearTimeout(this.timeout),this.hide(function(){t.$element.off("."+t.type).removeData("bs."+t.type),t.$tip&&t.$tip.detach(),t.$tip=null,t.$arrow=null,t.$viewport=null,t.$element=null})},m.prototype.sanitizeHtml=function(t){return n(t,this.options.whiteList,this.options.sanitizeFn)};var e=g.fn.tooltip;g.fn.tooltip=function i(o){return this.each(function(){var t=g(this),e=t.data("bs.tooltip"),i="object"==typeof o&&o;!e&&/destroy|hide/.test(o)||(e||t.data("bs.tooltip",e=new m(this,i)),"string"==typeof o&&e[o]())})},g.fn.tooltip.Constructor=m,g.fn.tooltip.noConflict=function(){return g.fn.tooltip=e,this}}(jQuery),function(n){"use strict";var s=function(t,e){this.init("popover",t,e)};if(!n.fn.tooltip)throw new Error("Popover requires tooltip.js");s.VERSION="3.4.1",s.DEFAULTS=n.extend({},n.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:'<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'}),((s.prototype=n.extend({},n.fn.tooltip.Constructor.prototype)).constructor=s).prototype.getDefaults=function(){return s.DEFAULTS},s.prototype.setContent=function(){var t=this.tip(),e=this.getTitle(),i=this.getContent();if(this.options.html){var o=typeof i;this.options.sanitize&&(e=this.sanitizeHtml(e),"string"===o&&(i=this.sanitizeHtml(i))),t.find(".popover-title").html(e),t.find(".popover-content").children().detach().end()["string"===o?"html":"append"](i)}else t.find(".popover-title").text(e),t.find(".popover-content").children().detach().end().text(i);t.removeClass("fade top bottom left right in"),t.find(".popover-title").html()||t.find(".popover-title").hide()},s.prototype.hasContent=function(){return this.getTitle()||this.getContent()},s.prototype.getContent=function(){var t=this.$element,e=this.options;return t.attr("data-content")||("function"==typeof e.content?e.content.call(t[0]):e.content)},s.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var t=n.fn.popover;n.fn.popover=function e(o){return this.each(function(){var t=n(this),e=t.data("bs.popover"),i="object"==typeof o&&o;!e&&/destroy|hide/.test(o)||(e||t.data("bs.popover",e=new s(this,i)),"string"==typeof o&&e[o]())})},n.fn.popover.Constructor=s,n.fn.popover.noConflict=function(){return n.fn.popover=t,this}}(jQuery),function(s){"use strict";function n(t,e){this.$body=s(document.body),this.$scrollElement=s(t).is(document.body)?s(window):s(t),this.options=s.extend({},n.DEFAULTS,e),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",s.proxy(this.process,this)),this.refresh(),this.process()}function e(o){return this.each(function(){var t=s(this),e=t.data("bs.scrollspy"),i="object"==typeof o&&o;e||t.data("bs.scrollspy",e=new n(this,i)),"string"==typeof o&&e[o]()})}n.VERSION="3.4.1",n.DEFAULTS={offset:10},n.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},n.prototype.refresh=function(){var t=this,o="offset",n=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),s.isWindow(this.$scrollElement[0])||(o="position",n=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map(function(){var t=s(this),e=t.data("target")||t.attr("href"),i=/^#./.test(e)&&s(e);return i&&i.length&&i.is(":visible")&&[[i[o]().top+n,e]]||null}).sort(function(t,e){return t[0]-e[0]}).each(function(){t.offsets.push(this[0]),t.targets.push(this[1])})},n.prototype.process=function(){var t,e=this.$scrollElement.scrollTop()+this.options.offset,i=this.getScrollHeight(),o=this.options.offset+i-this.$scrollElement.height(),n=this.offsets,s=this.targets,a=this.activeTarget;if(this.scrollHeight!=i&&this.refresh(),o<=e)return a!=(t=s[s.length-1])&&this.activate(t);if(a&&e<n[0])return this.activeTarget=null,this.clear();for(t=n.length;t--;)a!=s[t]&&e>=n[t]&&(n[t+1]===undefined||e<n[t+1])&&this.activate(s[t])},n.prototype.activate=function(t){this.activeTarget=t,this.clear();var e=this.selector+'[data-target="'+t+'"],'+this.selector+'[href="'+t+'"]',i=s(e).parents("li").addClass("active");i.parent(".dropdown-menu").length&&(i=i.closest("li.dropdown").addClass("active")),i.trigger("activate.bs.scrollspy")},n.prototype.clear=function(){s(this.selector).parentsUntil(this.options.target,".active").removeClass("active")};var t=s.fn.scrollspy;s.fn.scrollspy=e,s.fn.scrollspy.Constructor=n,s.fn.scrollspy.noConflict=function(){return s.fn.scrollspy=t,this},s(window).on("load.bs.scrollspy.data-api",function(){s('[data-spy="scroll"]').each(function(){var t=s(this);e.call(t,t.data())})})}(jQuery),function(r){"use strict";var a=function(t){this.element=r(t)};function e(i){return this.each(function(){var t=r(this),e=t.data("bs.tab");e||t.data("bs.tab",e=new a(this)),"string"==typeof i&&e[i]()})}a.VERSION="3.4.1",a.TRANSITION_DURATION=150,a.prototype.show=function(){var t=this.element,e=t.closest("ul:not(.dropdown-menu)"),i=t.data("target");if(i||(i=(i=t.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),!t.parent("li").hasClass("active")){var o=e.find(".active:last a"),n=r.Event("hide.bs.tab",{relatedTarget:t[0]}),s=r.Event("show.bs.tab",{relatedTarget:o[0]});if(o.trigger(n),t.trigger(s),!s.isDefaultPrevented()&&!n.isDefaultPrevented()){var a=r(document).find(i);this.activate(t.closest("li"),e),this.activate(a,a.parent(),function(){o.trigger({type:"hidden.bs.tab",relatedTarget:t[0]}),t.trigger({type:"shown.bs.tab",relatedTarget:o[0]})})}}},a.prototype.activate=function(t,e,i){var o=e.find("> .active"),n=i&&r.support.transition&&(o.length&&o.hasClass("fade")||!!e.find("> .fade").length);function s(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),t.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),n?(t[0].offsetWidth,t.addClass("in")):t.removeClass("fade"),t.parent(".dropdown-menu").length&&t.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&n?o.one("bsTransitionEnd",s).emulateTransitionEnd(a.TRANSITION_DURATION):s(),o.removeClass("in")};var t=r.fn.tab;r.fn.tab=e,r.fn.tab.Constructor=a,r.fn.tab.noConflict=function(){return r.fn.tab=t,this};var i=function(t){t.preventDefault(),e.call(r(this),"show")};r(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(l){"use strict";var h=function(t,e){this.options=l.extend({},h.DEFAULTS,e);var i=this.options.target===h.DEFAULTS.target?l(this.options.target):l(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",l.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",l.proxy(this.checkPositionWithEventLoop,this)),this.$element=l(t),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function i(o){return this.each(function(){var t=l(this),e=t.data("bs.affix"),i="object"==typeof o&&o;e||t.data("bs.affix",e=new h(this,i)),"string"==typeof o&&e[o]()})}h.VERSION="3.4.1",h.RESET="affix affix-top affix-bottom",h.DEFAULTS={offset:0,target:window},h.prototype.getState=function(t,e,i,o){var n=this.$target.scrollTop(),s=this.$element.offset(),a=this.$target.height();if(null!=i&&"top"==this.affixed)return n<i&&"top";if("bottom"==this.affixed)return null!=i?!(n+this.unpin<=s.top)&&"bottom":!(n+a<=t-o)&&"bottom";var r=null==this.affixed,l=r?n:s.top;return null!=i&&n<=i?"top":null!=o&&t-o<=l+(r?a:e)&&"bottom"},h.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(h.RESET).addClass("affix");var t=this.$target.scrollTop(),e=this.$element.offset();return this.pinnedOffset=e.top-t},h.prototype.checkPositionWithEventLoop=function(){setTimeout(l.proxy(this.checkPosition,this),1)},h.prototype.checkPosition=function(){if(this.$element.is(":visible")){var t=this.$element.height(),e=this.options.offset,i=e.top,o=e.bottom,n=Math.max(l(document).height(),l(document.body).height());"object"!=typeof e&&(o=i=e),"function"==typeof i&&(i=e.top(this.$element)),"function"==typeof o&&(o=e.bottom(this.$element));var s=this.getState(n,t,i,o);if(this.affixed!=s){null!=this.unpin&&this.$element.css("top","");var a="affix"+(s?"-"+s:""),r=l.Event(a+".bs.affix");if(this.$element.trigger(r),r.isDefaultPrevented())return;this.affixed=s,this.unpin="bottom"==s?this.getPinnedOffset():null,this.$element.removeClass(h.RESET).addClass(a).trigger(a.replace("affix","affixed")+".bs.affix")}"bottom"==s&&this.$element.offset({top:n-t-o})}};var t=l.fn.affix;l.fn.affix=i,l.fn.affix.Constructor=h,l.fn.affix.noConflict=function(){return l.fn.affix=t,this},l(window).on("load",function(){l('[data-spy="affix"]').each(function(){var t=l(this),e=t.data();e.offset=e.offset||{},null!=e.offsetBottom&&(e.offset.bottom=e.offsetBottom),null!=e.offsetTop&&(e.offset.top=e.offsetTop),i.call(t,e)})})}(jQuery);
\ No newline at end of file
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/js/jquery.min.js b/hbase-thrift/src/main/resources/hbase-webapps/static/js/jquery.min.js
new file mode 100644
index 0000000..b061403
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/js/jquery.min.js
@@ -0,0 +1,2 @@
+/*! jQuery v3.5.1 | (c) JS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.5.1",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),D=function(e,t){return e===t&&(l=!0),0},j={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="<a id='"+S+"'></a><select id='"+S+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!=C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&j.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(D),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(B," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[k,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[k,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace($,"$1"));return s[S]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[k,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[S]||(e[S]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===k&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[S]&&(v=Ce(v)),y&&!y[S]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace($,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace($," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=A[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[S]?i.push(a):o.push(a);(a=A(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=k+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(k=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(k=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=S.split("").sort(D).join("")===S,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);S.find=d,S.expr=d.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=d.uniqueSort,S.text=d.getText,S.isXMLDoc=d.isXML,S.contains=d.contains,S.escapeSelector=d.escape;var h=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&S(e).is(n))break;r.push(e)}return r},T=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=S.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function D(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1<i.call(n,e)!==r}):S.filter(n,e,r)}S.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?S.find.matchesSelector(r,e)?[r]:[]:S.find.matches(e,S.grep(t,function(e){return 1===e.nodeType}))},S.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(S(e).filter(function(){for(t=0;t<r;t++)if(S.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)S.find(e,i[t],n);return 1<r?S.uniqueSort(n):n},filter:function(e){return this.pushStack(D(this,e||[],!1))},not:function(e){return this.pushStack(D(this,e||[],!0))},is:function(e){return!!D(this,"string"==typeof e&&k.test(e)?S(e):e||[],!1).length}});var j,q=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||j,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,j=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(S.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&S(e);if(!k.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?S.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(S(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return h(e,"parentNode")},parentsUntil:function(e,t,n){return h(e,"parentNode",n)},next:function(e){return O(e,"nextSibling")},prev:function(e){return O(e,"previousSibling")},nextAll:function(e){return h(e,"nextSibling")},prevAll:function(e){return h(e,"previousSibling")},nextUntil:function(e,t,n){return h(e,"nextSibling",n)},prevUntil:function(e,t,n){return h(e,"previousSibling",n)},siblings:function(e){return T((e.parentNode||{}).firstChild,e)},children:function(e){return T(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},function(r,i){S.fn[r]=function(e,t){var n=S.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=S.filter(t,n)),1<this.length&&(H[r]||S.uniqueSort(n),L.test(r)&&n.reverse()),this.pushStack(n)}});var P=/[^\x20\t\r\n\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},S.each(e.match(P)||[],function(e,t){n[t]=!0}),n):S.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){S.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return S.each(arguments,function(e,t){var n;while(-1<(n=S.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<S.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},S.extend({Deferred:function(e){var o=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return S.Deferred(function(r){S.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,R,s),l(u,o,M,s)):(u++,t.call(e,l(u,o,R,s),l(u,o,M,s),l(u,o,R,o.notifyWith))):(a!==R&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){S.Deferred.exceptionHook&&S.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==M&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(S.Deferred.getStackHook&&(t.stackTrace=S.Deferred.getStackHook()),C.setTimeout(t))}}return S.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:R,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:R)),o[2][3].add(l(0,e,m(n)?n:M))}).promise()},promise:function(e){return null!=e?S.extend(e,a):a}},s={};return S.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=S.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(I(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)I(i[t],a(t),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&W.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){C.setTimeout(function(){throw e})};var F=S.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),S.ready()}S.fn.ready=function(e){return F.then(e)["catch"](function(e){S.readyException(e)}),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0)!==e&&0<--S.readyWait||F.resolveWith(E,[S])}}),S.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(S.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(S(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},_=/^-ms-/,z=/-([a-z])/g;function U(e,t){return t.toUpperCase()}function X(e){return e.replace(_,"ms-").replace(z,U)}var V=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function G(){this.expando=S.expando+G.uid++}G.uid=1,G.prototype={cache:function(e){var t=e[this.expando];return t||(t={},V(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[X(t)]=n;else for(r in t)i[X(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][X(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(X):(t=X(t))in r?[t]:t.match(P)||[]).length;while(n--)delete r[t[n]]}(void 0===t||S.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!S.isEmptyObject(t)}};var Y=new G,Q=new G,J=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,K=/[A-Z]/g;function Z(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(K,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:J.test(i)?JSON.parse(i):i)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}S.extend({hasData:function(e){return Q.hasData(e)||Y.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return Y.access(e,t,n)},_removeData:function(e,t){Y.remove(e,t)}}),S.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=Q.get(o),1===o.nodeType&&!Y.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=X(r.slice(5)),Z(o,r,i[r]));Y.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){Q.set(this,n)}):$(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=Q.get(o,n))?t:void 0!==(t=Z(o,n))?t:void 0;this.each(function(){Q.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),S.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,S.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),r=n.length,i=n.shift(),o=S._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){S.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Y.get(e,n)||Y.access(e,n,{empty:S.Callbacks("once memory").add(function(){Y.remove(e,[t+"queue",n])})})}}),S.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?S.queue(this[0],t):void 0===n?this:this.each(function(){var e=S.queue(this,t,n);S._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&S.dequeue(this,t)})},dequeue:function(e){return this.each(function(){S.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=S.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Y.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var ee=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,te=new RegExp("^(?:([+-])=|)("+ee+")([a-z%]*)$","i"),ne=["Top","Right","Bottom","Left"],re=E.documentElement,ie=function(e){return S.contains(e.ownerDocument,e)},oe={composed:!0};re.getRootNode&&(ie=function(e){return S.contains(e.ownerDocument,e)||e.getRootNode(oe)===e.ownerDocument});var ae=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&ie(e)&&"none"===S.css(e,"display")};function se(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return S.css(e,t,"")},u=s(),l=n&&n[3]||(S.cssNumber[t]?"":"px"),c=e.nodeType&&(S.cssNumber[t]||"px"!==l&&+u)&&te.exec(S.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)S.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,S.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ue={};function le(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Y.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ae(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ue[s])||(o=a.body.appendChild(a.createElement(s)),u=S.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ue[s]=u)))):"none"!==n&&(l[c]="none",Y.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}S.fn.extend({show:function(){return le(this,!0)},hide:function(){return le(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ae(this)?S(this).show():S(this).hide()})}});var ce,fe,pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="<option></option>",y.option=!!ce.lastChild;var ge={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Y.set(e[n],"globalEval",!t||Y.get(t[n],"globalEval"))}ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td,y.option||(ge.optgroup=ge.option=[1,"<select multiple='multiple'>","</select>"]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))S.merge(p,o.nodeType?[o]:o);else if(me.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+S.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;S.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<S.inArray(o,r))i&&i.push(o);else if(l=ie(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}var be=/^key/,we=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Te=/^([^.]*)(?:\.(.+)|)/;function Ce(){return!0}function Ee(){return!1}function Se(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function ke(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)ke(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Ee;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,i,r,n)})}function Ae(e,i,o){o?(Y.set(e,i,!1),S.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Y.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(S.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Y.set(this,i,r),t=o(this,i),this[i](),r!==(n=Y.get(this,i))||t?Y.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Y.set(this,i,{value:S.event.trigger(S.extend(r[0],S.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,i)&&S.event.add(e,i,Ce)}S.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(t);if(V(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&S.find.matchesSelector(re,i),n.guid||(n.guid=S.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(P)||[""]).length;while(l--)d=g=(s=Te.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=S.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=S.event.special[d]||{},c=S.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&S.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),S.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(P)||[""]).length;while(l--)if(d=g=(s=Te.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=S.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||S.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)S.event.remove(e,d+t[l],n,r,!0);S.isEmptyObject(u)&&Y.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=S.event.fix(e),l=(Y.get(this,"events")||Object.create(null))[u.type]||[],c=S.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=S.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((S.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<S(i,this).index(l):S.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(S.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[S.expando]?e:new S.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Ae(t,"click",Ce),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Ae(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Y.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},S.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},S.Event=function(e,t){if(!(this instanceof S.Event))return new S.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?Ce:Ee,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&S.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[S.expando]=!0},S.Event.prototype={constructor:S.Event,isDefaultPrevented:Ee,isPropagationStopped:Ee,isImmediatePropagationStopped:Ee,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=Ce,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=Ce,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=Ce,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},S.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&be.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&we.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},S.event.addProp),S.each({focus:"focusin",blur:"focusout"},function(e,t){S.event.special[e]={setup:function(){return Ae(this,e,Se),!1},trigger:function(){return Ae(this,e),!0},delegateType:t}}),S.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){S.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||S.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),S.fn.extend({on:function(e,t,n,r){return ke(this,e,t,n,r)},one:function(e,t,n,r){return ke(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,S(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Ee),this.each(function(){S.event.remove(this,e,n,t)})}});var Ne=/<script|<style|<link/i,De=/checked\s*(?:[^=]|=\s*.checked.)/i,je=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function qe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function Le(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function He(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Oe(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)S.event.add(t,i,s[i][n]);Q.hasData(e)&&(o=Q.access(e),a=S.extend({},o),Q.set(t,a))}}function Pe(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&De.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),Pe(t,r,i,o)});if(f&&(t=(e=xe(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=S.map(ve(e,"script"),Le)).length;c<f;c++)u=e,c!==p&&(u=S.clone(u,!0,!0),s&&S.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,S.map(a,He),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Y.access(u,"globalEval")&&S.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?S._evalUrl&&!u.noModule&&S._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):b(u.textContent.replace(je,""),u,l))}return n}function Re(e,t,n){for(var r,i=t?S.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||S.cleanData(ve(r)),r.parentNode&&(n&&ie(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}S.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=ie(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Oe(o[r],a[r]);else Oe(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=S.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?S.event.remove(n,r):S.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Re(this,e,!0)},remove:function(e){return Re(this,e)},text:function(e){return $(this,function(e){return void 0===e?S.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return Pe(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||qe(this,e).appendChild(e)})},prepend:function(){return Pe(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=qe(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return Pe(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return Pe(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return S.clone(this,e,t)})},html:function(e){return $(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!Ne.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(S.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return Pe(this,arguments,function(e){var t=this.parentNode;S.inArray(this,n)<0&&(S.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),S.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){S.fn[e]=function(e){for(var t,n=[],r=S(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),S(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var Me=new RegExp("^("+ee+")(?!px)[a-z%]+$","i"),Ie=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},We=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Fe=new RegExp(ne.join("|"),"i");function Be(e,t,n){var r,i,o,a,s=e.style;return(n=n||Ie(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||ie(e)||(a=S.style(e,t)),!y.pixelBoxStyles()&&Me.test(a)&&Fe.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function $e(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",re.appendChild(u).appendChild(l);var e=C.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),re.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=E.createElement("div"),l=E.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===l.style.backgroundClip,S.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=E.createElement("table"),t=E.createElement("tr"),n=E.createElement("div"),e.style.cssText="position:absolute;left:-11111px",t.style.height="1px",n.style.height="9px",re.appendChild(e).appendChild(t).appendChild(n),r=C.getComputedStyle(t),a=3<parseInt(r.height),re.removeChild(e)),a}}))}();var _e=["Webkit","Moz","ms"],ze=E.createElement("div").style,Ue={};function Xe(e){var t=S.cssProps[e]||Ue[e];return t||(e in ze?e:Ue[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=_e.length;while(n--)if((e=_e[n]+t)in ze)return e}(e)||e)}var Ve=/^(none|table(?!-c[ea]).+)/,Ge=/^--/,Ye={position:"absolute",visibility:"hidden",display:"block"},Qe={letterSpacing:"0",fontWeight:"400"};function Je(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function Ke(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=S.css(e,n+ne[a],!0,i)),r?("content"===n&&(u-=S.css(e,"padding"+ne[a],!0,i)),"margin"!==n&&(u-=S.css(e,"border"+ne[a]+"Width",!0,i))):(u+=S.css(e,"padding"+ne[a],!0,i),"padding"!==n?u+=S.css(e,"border"+ne[a]+"Width",!0,i):s+=S.css(e,"border"+ne[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function Ze(e,t,n){var r=Ie(e),i=(!y.boxSizingReliable()||n)&&"border-box"===S.css(e,"boxSizing",!1,r),o=i,a=Be(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Me.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||!y.reliableTrDimensions()&&A(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===S.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===S.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+Ke(e,t,n||(i?"border":"content"),o,r,a)+"px"}function et(e,t,n,r,i){return new et.prototype.init(e,t,n,r,i)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Be(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=X(t),u=Ge.test(t),l=e.style;if(u||(t=Xe(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(S.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Ge.test(t)||(t=Xe(s)),(a=S.cssHooks[t]||S.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=Be(e,t,r)),"normal"===i&&t in Qe&&(i=Qe[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),S.each(["height","width"],function(e,u){S.cssHooks[u]={get:function(e,t,n){if(t)return!Ve.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?Ze(e,u,n):We(e,Ye,function(){return Ze(e,u,n)})},set:function(e,t,n){var r,i=Ie(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===S.css(e,"boxSizing",!1,i),s=n?Ke(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-Ke(e,u,"border",!1,i)-.5)),s&&(r=te.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=S.css(e,u)),Je(0,t,s)}}}),S.cssHooks.marginLeft=$e(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(Be(e,"marginLeft"))||e.getBoundingClientRect().left-We(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),S.each({margin:"",padding:"",border:"Width"},function(i,o){S.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+ne[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(S.cssHooks[i+o].set=Je)}),S.fn.extend({css:function(e,t){return $(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Ie(e),i=t.length;a<i;a++)o[t[a]]=S.css(e,t[a],!1,r);return o}return void 0!==n?S.style(e,t,n):S.css(e,t)},e,t,1<arguments.length)}}),((S.Tween=et).prototype={constructor:et,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=et.propHooks[this.prop];return e&&e.get?e.get(this):et.propHooks._default.get(this)},run:function(e){var t,n=et.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):et.propHooks._default.set(this),this}}).init.prototype=et.prototype,(et.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[Xe(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=et.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=et.prototype.init,S.fx.step={};var tt,nt,rt,it,ot=/^(?:toggle|show|hide)$/,at=/queueHooks$/;function st(){nt&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(st):C.setTimeout(st,S.fx.interval),S.fx.tick())}function ut(){return C.setTimeout(function(){tt=void 0}),tt=Date.now()}function lt(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ne[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ct(e,t,n){for(var r,i=(ft.tweeners[t]||[]).concat(ft.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function ft(o,e,t){var n,a,r=0,i=ft.prefilters.length,s=S.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=tt||ut(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:S.extend({},e),opts:S.extend(!0,{specialEasing:{},easing:S.easing._default},t),originalProperties:e,originalOptions:t,startTime:tt||ut(),duration:t.duration,tweens:[],createTween:function(e,t){var n=S.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=X(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=S.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=ft.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(S._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return S.map(c,ct,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),S.fx.timer(S.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}S.Animation=S.extend(ft,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return se(n.elem,e,te.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(P);for(var n,r=0,i=e.length;r<i;r++)n=e[r],ft.tweeners[n]=ft.tweeners[n]||[],ft.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ae(e),v=Y.get(e,"fxshow");for(r in n.queue||(null==(a=S._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,S.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],ot.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||S.style(e,r)}if((u=!S.isEmptyObject(t))||!S.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Y.get(e,"display")),"none"===(c=S.css(e,"display"))&&(l?c=l:(le([e],!0),l=e.style.display||l,c=S.css(e,"display"),le([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===S.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Y.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&le([e],!0),p.done(function(){for(r in g||le([e]),Y.remove(e,"fxshow"),d)S.style(e,r,d[r])})),u=ct(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?ft.prefilters.unshift(e):ft.prefilters.push(e)}}),S.speed=function(e,t,n){var r=e&&"object"==typeof e?S.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return S.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in S.fx.speeds?r.duration=S.fx.speeds[r.duration]:r.duration=S.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&S.dequeue(this,r.queue)},r},S.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ae).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=S.isEmptyObject(t),o=S.speed(e,n,r),a=function(){var e=ft(this,S.extend({},t),o);(i||Y.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=S.timers,r=Y.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&at.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||S.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Y.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=S.timers,o=n?n.length:0;for(t.finish=!0,S.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),S.each(["toggle","show","hide"],function(e,r){var i=S.fn[r];S.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(lt(r,!0),e,t,n)}}),S.each({slideDown:lt("show"),slideUp:lt("hide"),slideToggle:lt("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){S.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),S.timers=[],S.fx.tick=function(){var e,t=0,n=S.timers;for(tt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||S.fx.stop(),tt=void 0},S.fx.timer=function(e){S.timers.push(e),S.fx.start()},S.fx.interval=13,S.fx.start=function(){nt||(nt=!0,st())},S.fx.stop=function(){nt=null},S.fx.speeds={slow:600,fast:200,_default:400},S.fn.delay=function(r,e){return r=S.fx&&S.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},rt=E.createElement("input"),it=E.createElement("select").appendChild(E.createElement("option")),rt.type="checkbox",y.checkOn=""!==rt.value,y.optSelected=it.selected,(rt=E.createElement("input")).value="t",rt.type="radio",y.radioValue="t"===rt.value;var pt,dt=S.expr.attrHandle;S.fn.extend({attr:function(e,t){return $(this,S.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){S.removeAttr(this,e)})}}),S.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(i=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?pt:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=S.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(P);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),pt={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),function(e,t){var a=dt[t]||S.find.attr;dt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=dt[o],dt[o]=r,r=null!=a(e,t,n)?o:null,dt[o]=i),r}});var ht=/^(?:input|select|textarea|button)$/i,gt=/^(?:a|area)$/i;function vt(e){return(e.match(P)||[]).join(" ")}function yt(e){return e.getAttribute&&e.getAttribute("class")||""}function mt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(P)||[]}S.fn.extend({prop:function(e,t){return $(this,S.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[S.propFix[e]||e]})}}),S.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,i=S.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):ht.test(e.nodeName)||gt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){S.propFix[this.toLowerCase()]=this}),S.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).addClass(t.call(this,e,yt(this)))});if((e=mt(t)).length)while(n=this[u++])if(i=yt(n),r=1===n.nodeType&&" "+vt(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).removeClass(t.call(this,e,yt(this)))});if(!arguments.length)return this.attr("class","");if((e=mt(t)).length)while(n=this[u++])if(i=yt(n),r=1===n.nodeType&&" "+vt(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){S(this).toggleClass(i.call(this,e,yt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=S(this),r=mt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=yt(this))&&Y.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Y.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+vt(yt(n))+" ").indexOf(t))return!0;return!1}});var xt=/\r/g;S.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,S(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=S.map(t,function(e){return null==e?"":e+""})),(r=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=S.valHooks[t.type]||S.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(xt,""):null==e?"":e:void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:vt(S.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=S(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=S.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<S.inArray(S.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<S.inArray(S(e).val(),t)}},y.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var bt=/^(?:focusinfocus|focusoutblur)$/,wt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!bt.test(d+S.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[S.expando]?e:new S.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:S.makeArray(t,[e]),c=S.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,bt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Y.get(o,"events")||Object.create(null))[e.type]&&Y.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&V(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!V(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),S.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,wt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,wt),S.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(r,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each(function(){S.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),y.focusin||S.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){S.event.simulate(r,e.target,S.event.fix(e))};S.event.special[r]={setup:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r);t||e.addEventListener(n,i,!0),Y.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r)-1;t?Y.access(e,r,t):(e.removeEventListener(n,i,!0),Y.remove(e,r))}}});var Tt=C.location,Ct={guid:Date.now()},Et=/\?/;S.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||S.error("Invalid XML: "+e),t};var St=/\[\]$/,kt=/\r?\n/g,At=/^(?:submit|button|image|reset|file)$/i,Nt=/^(?:input|select|textarea|keygen)/i;function Dt(n,e,r,i){var t;if(Array.isArray(e))S.each(e,function(e,t){r||St.test(n)?i(n,t):Dt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)Dt(n+"["+t+"]",e[t],r,i)}S.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,function(){i(this.name,this.value)});else for(n in e)Dt(n,e[n],t,i);return r.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&Nt.test(this.nodeName)&&!At.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,function(e){return{name:t.name,value:e.replace(kt,"\r\n")}}):{name:t.name,value:n.replace(kt,"\r\n")}}).get()}});var jt=/%20/g,qt=/#.*$/,Lt=/([?&])_=[^&]*/,Ht=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ot=/^(?:GET|HEAD)$/,Pt=/^\/\//,Rt={},Mt={},It="*/".concat("*"),Wt=E.createElement("a");function Ft(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(P)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Bt(t,i,o,a){var s={},u=t===Mt;function l(e){var r;return s[e]=!0,S.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function $t(e,t){var n,r,i=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&S.extend(!0,e,r),e}Wt.href=Tt.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Tt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Tt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":It,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?$t($t(e,S.ajaxSettings),t):$t(S.ajaxSettings,e)},ajaxPrefilter:Ft(Rt),ajaxTransport:Ft(Mt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=S.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?S(y):S.event,x=S.Deferred(),b=S.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Ht.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Tt.href)+"").replace(Pt,Tt.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(P)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Wt.protocol+"//"+Wt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=S.param(v.data,v.traditional)),Bt(Rt,v,t,T),h)return T;for(i in(g=S.event&&v.global)&&0==S.active++&&S.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Ot.test(v.type),f=v.url.replace(qt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(jt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(Et.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Lt,"$1"),o=(Et.test(f)?"&":"?")+"_="+Ct.guid+++o),v.url=f+o),v.ifModified&&(S.lastModified[f]&&T.setRequestHeader("If-Modified-Since",S.lastModified[f]),S.etag[f]&&T.setRequestHeader("If-None-Match",S.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+It+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Bt(Mt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<S.inArray("script",v.dataTypes)&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(S.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(S.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--S.active||S.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],function(e,i){S[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),S.ajax(S.extend({url:e,type:i,dataType:r,data:t,success:n},S.isPlainObject(e)&&e))}}),S.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){S(this).wrapInner(n.call(this,e))}):this.each(function(){var e=S(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){S(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){S(this).replaceWith(this.childNodes)}),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var _t={0:200,1223:204},zt=S.ajaxSettings.xhr();y.cors=!!zt&&"withCredentials"in zt,y.ajax=zt=!!zt,S.ajaxTransport(function(i){var o,a;if(y.cors||zt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(_t[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),S.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),S.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=S("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Ut,Xt=[],Vt=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Xt.pop()||S.expando+"_"+Ct.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Vt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Vt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Vt,"$1"+r):!1!==e.jsonp&&(e.url+=(Et.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Xt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Ut=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Ut.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=vt(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&S.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?S("<div>").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):("number"==typeof f.top&&(f.top+="px"),"number"==typeof f.left&&(f.left+="px"),c.css(f))}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=$e(y.pixelPosition,function(e,t){if(t)return t=Be(e,n),Me.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var Gt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;S.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||S.guid++,i},S.holdReady=function(e){e?S.readyWait++:S.ready(!0)},S.isArray=Array.isArray,S.parseJSON=JSON.parse,S.nodeName=A,S.isFunction=m,S.isWindow=x,S.camelCase=X,S.type=w,S.now=Date.now,S.isNumeric=function(e){var t=S.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},S.trim=function(e){return null==e?"":(e+"").replace(Gt,"")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return S});var Yt=C.jQuery,Qt=C.$;return S.noConflict=function(e){return C.$===S&&(C.$=Qt),e&&C.jQuery===S&&(C.jQuery=Yt),S},"undefined"==typeof e&&(C.jQuery=C.$=S),S});
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/static/js/tab.js b/hbase-thrift/src/main/resources/hbase-webapps/static/js/tab.js
new file mode 100644
index 0000000..31438a1
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/static/js/tab.js
@@ -0,0 +1,38 @@
+/*
+ * Copyright 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.
+ */
+
+$(document).ready(
+ function(){
+ var prefix = "tab_";
+ $('.tabbable .nav-pills a').click(function (e) {
+ e.preventDefault();
+ location.hash = $(e.target).attr('href').substr(1).replace(prefix, "");
+ $(this).tab('show');
+ });
+
+ if (location.hash !== '') {
+ var tabItem = $('a[href="' + location.hash.replace("#", "#"+prefix) + '"]');
+ tabItem.tab('show');
+ $(document).scrollTop(0);
+ return false;
+ }
+ return true;
+ }
+);
\ No newline at end of file
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/thrift/index.html b/hbase-thrift/src/main/resources/hbase-webapps/thrift/index.html
new file mode 100644
index 0000000..9925269
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/thrift/index.html
@@ -0,0 +1,20 @@
+<!--
+/**
+ * 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.
+ */
+-->
+<meta HTTP-EQUIV="REFRESH" content="0;url=/thrift.jsp"/>
diff --git a/hbase-thrift/src/main/resources/hbase-webapps/thrift/thrift.jsp b/hbase-thrift/src/main/resources/hbase-webapps/thrift/thrift.jsp
new file mode 100644
index 0000000..cae1b3d
--- /dev/null
+++ b/hbase-thrift/src/main/resources/hbase-webapps/thrift/thrift.jsp
@@ -0,0 +1,162 @@
+<%--
+/**
+ * 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.
+ */
+--%>
+<%@ page contentType="text/html;charset=UTF-8"
+ import="org.apache.hadoop.conf.Configuration"
+ import="org.apache.hadoop.hbase.HBaseConfiguration"
+ import="org.apache.hadoop.hbase.util.VersionInfo"
+ import="java.util.Date"
+%>
+<%@ page import="org.apache.hadoop.hbase.thrift.ImplType" %>
+<%@ page import="org.apache.hadoop.hbase.util.JvmVersion" %>
+
+<%
+Configuration conf = (Configuration)getServletContext().getAttribute("hbase.conf");
+String serverType = (String)getServletContext().getAttribute("hbase.thrift.server.type");
+long startcode = conf.getLong("startcode", System.currentTimeMillis());
+String listenPort = conf.get("hbase.regionserver.thrift.port", "9090");
+ImplType implType = ImplType.getServerImpl(conf);
+
+String transport =
+ (implType.isAlwaysFramed() ||
+ conf.getBoolean("hbase.regionserver.thrift.framed", false)) ? "Framed" : "Standard";
+String protocol =
+ conf.getBoolean("hbase.regionserver.thrift.compact", false) ? "Compact" : "Binary";
+String qop = conf.get("hbase.thrift.security.qop", "None");
+
+%>
+<!DOCTYPE html>
+<?xml version="1.0" encoding="UTF-8" ?>
+<html lang="en">
+ <head>
+ <meta charset="utf-8">
+ <title>HBase Thrift Server: <%= listenPort %></title>
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="description" content="">
+
+ <link href="/static/css/bootstrap.min.css" rel="stylesheet">
+ <link href="/static/css/bootstrap-theme.min.css" rel="stylesheet">
+ <link href="/static/css/hbase.css" rel="stylesheet">
+ </head>
+
+ <body>
+ <div class="navbar navbar-fixed-top navbar-default">
+ <div class="container-fluid">
+ <div class="navbar-header">
+ <button type="button"
+ class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
+ <span class="icon-bar"></span>
+ <span class="icon-bar"></span>
+ <span class="icon-bar"></span>
+ </button>
+ <a class="navbar-brand" href="/thrift.jsp">
+ <img src="/static/hbase_logo_small.png" alt="HBase Logo"/>
+ </a>
+ </div>
+ <div class="collapse navbar-collapse">
+ <ul class="nav navbar-nav">
+ <li class="active"><a href="/">Home</a></li>
+ <li><a href="/logs/">Local logs</a></li>
+ <li><a href="/logLevel">Log Level</a></li>
+ <li><a href="/jmx">Metrics Dump</a></li>
+ <li><a href="/prof">Profiler</a></li>
+ <% if (HBaseConfiguration.isShowConfInServlet()) { %>
+ <li><a href="/conf">HBase Configuration</a></li>
+ <% } %>
+ </ul>
+ </div><!--/.nav-collapse -->
+ </div>
+ </div>
+
+<div class="container-fluid content">
+ <div class="row inner_header">
+ <div class="page-header">
+ <h1>ThriftServer <small><%= listenPort %></small></h1>
+ </div>
+ </div>
+ <div class="row">
+
+ <section>
+ <h2>Software Attributes</h2>
+ <table id="attributes_table" class="table table-striped">
+ <tr>
+ <th>Attribute Name</th>
+ <th>Value</th>
+ <th>Description</th>
+ </tr>
+ <tr>
+ <td>JVM Version</td>
+ <td><%= JvmVersion.getVersion() %></td>
+ <td>JVM vendor and version information</td>
+ </tr>
+ <tr>
+ <td>HBase Version</td>
+ <td><%= VersionInfo.getVersion() %>, r<%= VersionInfo.getRevision() %></td>
+ <td>HBase version and revision</td>
+ </tr>
+ <tr>
+ <td>HBase Compiled</td>
+ <td><%= VersionInfo.getDate() %>, <%= VersionInfo.getUser() %></td>
+ <td>When HBase version was compiled and by whom</td>
+ </tr>
+ <tr>
+ <td>Thrift Server Start Time</td>
+ <td><%= new Date(startcode) %></td>
+ <td>Date stamp of when this Thrift server was started</td>
+ </tr>
+ <tr>
+ <td>Thrift Impl Type</td>
+ <td><%= implType.getOption() %></td>
+ <td>Thrift RPC engine implementation type chosen by this Thrift server</td>
+ </tr>
+ <tr>
+ <td>Protocol</td>
+ <td><%= protocol %></td>
+ <td>Thrift RPC engine protocol type</td>
+ </tr>
+ <tr>
+ <td>Transport</td>
+ <td><%= transport %></td>
+ <td>Thrift RPC engine transport type</td>
+ </tr>
+ <tr>
+ <td>Thrift Server Type</td>
+ <td><%= serverType %></td>
+ <td>The type of this Thrift server</td>
+ </tr>
+ <tr>
+ <td>Quality of Protection</td>
+ <td><%= qop %></td>
+ <td>QOP Settings for SASL</td>
+ </tr>
+ </table>
+ </section>
+ </div>
+ <div class="row">
+ <section>
+ <a href="http://hbase.apache.org/book.html#_thrift">
+ Apache HBase Reference Guide chapter on Thrift</a>
+ </section>
+ </div>
+</div>
+<script src="/static/js/jquery.min.js" type="text/javascript"></script>
+<script src="/static/js/bootstrap.min.js" type="text/javascript"></script>
+<script src="/static/js/tab.js" type="text/javascript"></script>
+</body>
+</html>
diff --git a/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift
new file mode 100644
index 0000000..8b204b3
--- /dev/null
+++ b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift
@@ -0,0 +1,1019 @@
+/*
+ * 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.
+ */
+
+// ----------------------------------------------------------------
+// Hbase.thrift
+//
+// This is a Thrift interface definition file for the Hbase service.
+// Target language libraries for C++, Java, Ruby, PHP, (and more) are
+// generated by running this file through the Thrift compiler with the
+// appropriate flags. The Thrift compiler binary and runtime
+// libraries for various languages are available
+// from the Apache Incubator (http://incubator.apache.org/thrift/)
+//
+// See the package.html file for information on the version of Thrift
+// used to generate the *.java files checked into the Hbase project.
+// ----------------------------------------------------------------
+
+namespace java org.apache.hadoop.hbase.thrift.generated
+namespace cpp apache.hadoop.hbase.thrift
+namespace rb Apache.Hadoop.Hbase.Thrift
+namespace py hbase
+namespace perl Hbase
+namespace php Hbase
+//
+// Types
+//
+
+// NOTE: all variables with the Text type are assumed to be correctly
+// formatted UTF-8 strings. This is a programming language and locale
+// dependent property that the client application is repsonsible for
+// maintaining. If strings with an invalid encoding are sent, an
+// IOError will be thrown.
+
+typedef binary Text
+typedef binary Bytes
+typedef i32 ScannerID
+
+/**
+ * TCell - Used to transport a cell value (byte[]) and the timestamp it was
+ * stored with together as a result for get and getRow methods. This promotes
+ * the timestamp of a cell to a first-class value, making it easy to take
+ * note of temporal data. Cell is used all the way from HStore up to HTable.
+ */
+struct TCell{
+ 1:Bytes value,
+ 2:i64 timestamp
+}
+
+/**
+ * An HColumnDescriptor contains information about a column family
+ * such as the number of versions, compression settings, etc. It is
+ * used as input when creating a table or adding a column.
+ */
+struct ColumnDescriptor {
+ 1:Text name,
+ 2:i32 maxVersions = 3,
+ 3:string compression = "NONE",
+ 4:bool inMemory = 0,
+ 5:string bloomFilterType = "NONE",
+ 6:i32 bloomFilterVectorSize = 0,
+ 7:i32 bloomFilterNbHashes = 0,
+ 8:bool blockCacheEnabled = 0,
+ 9:i32 timeToLive = 0x7fffffff
+}
+
+/**
+ * A TRegionInfo contains information about an HTable region.
+ */
+struct TRegionInfo {
+ 1:Text startKey,
+ 2:Text endKey,
+ 3:i64 id,
+ 4:Text name,
+ 5:byte version,
+ 6:Text serverName,
+ 7:i32 port
+}
+
+/**
+ * A Mutation object is used to either update or delete a column-value.
+ */
+struct Mutation {
+ 1:bool isDelete = 0,
+ 2:Text column,
+ 3:Text value,
+ 4:bool writeToWAL = 1
+}
+
+
+/**
+ * A BatchMutation object is used to apply a number of Mutations to a single row.
+ */
+struct BatchMutation {
+ 1:Text row,
+ 2:list<Mutation> mutations
+}
+
+/**
+ * For increments that are not incrementColumnValue
+ * equivalents.
+ */
+struct TIncrement {
+ 1:Text table,
+ 2:Text row,
+ 3:Text column,
+ 4:i64 ammount
+}
+
+/**
+ * Holds column name and the cell.
+ */
+struct TColumn {
+ 1:Text columnName,
+ 2:TCell cell
+ }
+
+/**
+ * Holds row name and then a map of columns to cells.
+ */
+struct TRowResult {
+ 1:Text row,
+ 2:optional map<Text, TCell> columns,
+ 3:optional list<TColumn> sortedColumns
+}
+
+/**
+ * A Scan object is used to specify scanner parameters when opening a scanner.
+ */
+struct TScan {
+ 1:optional Text startRow,
+ 2:optional Text stopRow,
+ 3:optional i64 timestamp,
+ 4:optional list<Text> columns,
+ 5:optional i32 caching,
+ 6:optional Text filterString,
+ 7:optional i32 batchSize,
+ 8:optional bool sortColumns,
+ 9:optional bool reversed,
+ 10:optional bool cacheBlocks
+}
+
+/**
+ * An Append object is used to specify the parameters for performing the append operation.
+ */
+struct TAppend {
+ 1:Text table,
+ 2:Text row,
+ 3:list<Text> columns,
+ 4:list<Text> values
+}
+
+//
+// Exceptions
+//
+/**
+ * An IOError exception signals that an error occurred communicating
+ * to the Hbase master or an Hbase region server. Also used to return
+ * more general Hbase error conditions.
+ */
+exception IOError {
+ 1:string message
+ 2:bool canRetry
+}
+
+/**
+ * An IllegalArgument exception indicates an illegal or invalid
+ * argument was passed into a procedure.
+ */
+exception IllegalArgument {
+ 1:string message
+}
+
+/**
+ * An AlreadyExists exceptions signals that a table with the specified
+ * name already exists
+ */
+exception AlreadyExists {
+ 1:string message
+}
+
+/**
+ * Specify type of thrift server: thrift and thrift2
+ */
+enum TThriftServerType {
+ ONE = 1,
+ TWO = 2
+}
+
+enum TPermissionScope {
+ TABLE = 0,
+ NAMESPACE = 1
+}
+
+/**
+ * TAccessControlEntity for permission control
+ */
+struct TAccessControlEntity {
+ 1: required string username
+ 2: required TPermissionScope scope
+ 4: required string actions
+ 5: optional Bytes tableName
+ 6: optional string nsName
+}
+
+//
+// Service
+//
+
+service Hbase {
+ /**
+ * Brings a table on-line (enables it)
+ */
+ void enableTable(
+ /** name of the table */
+ 1:Bytes tableName
+ ) throws (1:IOError io)
+
+ /**
+ * Disables a table (takes it off-line) If it is being served, the master
+ * will tell the servers to stop serving it.
+ */
+ void disableTable(
+ /** name of the table */
+ 1:Bytes tableName
+ ) throws (1:IOError io)
+
+ /**
+ * @return true if table is on-line
+ */
+ bool isTableEnabled(
+ /** name of the table to check */
+ 1:Bytes tableName
+ ) throws (1:IOError io)
+
+ void compact(1:Bytes tableNameOrRegionName)
+ throws (1:IOError io)
+
+ void majorCompact(1:Bytes tableNameOrRegionName)
+ throws (1:IOError io)
+
+ /**
+ * List all the userspace tables.
+ *
+ * @return returns a list of names
+ */
+ list<Text> getTableNames()
+ throws (1:IOError io)
+
+ /**
+ * List all the userspace tables and their enabled or disabled flags.
+ *
+ * @return list of tables with is enabled flags
+ */
+ map<Text,bool> getTableNamesWithIsTableEnabled()
+ throws (1:IOError io)
+
+ /**
+ * List all the column families assoicated with a table.
+ *
+ * @return list of column family descriptors
+ */
+ map<Text,ColumnDescriptor> getColumnDescriptors (
+ /** table name */
+ 1:Text tableName
+ ) throws (1:IOError io)
+
+ /**
+ * List the regions associated with a table.
+ *
+ * @return list of region descriptors
+ */
+ list<TRegionInfo> getTableRegions(
+ /** table name */
+ 1:Text tableName)
+ throws (1:IOError io)
+
+ /**
+ * Create a table with the specified column families. The name
+ * field for each ColumnDescriptor must be set and must end in a
+ * colon (:). All other fields are optional and will get default
+ * values if not explicitly specified.
+ *
+ * @throws IllegalArgument if an input parameter is invalid
+ *
+ * @throws AlreadyExists if the table name already exists
+ */
+ void createTable(
+ /** name of table to create */
+ 1:Text tableName,
+
+ /** list of column family descriptors */
+ 2:list<ColumnDescriptor> columnFamilies
+ ) throws (1:IOError io, 2:IllegalArgument ia, 3:AlreadyExists exist)
+
+ /**
+ * Deletes a table
+ *
+ * @throws IOError if table doesn't exist on server or there was some other
+ * problem
+ */
+ void deleteTable(
+ /** name of table to delete */
+ 1:Text tableName
+ ) throws (1:IOError io)
+
+ /**
+ * Get a single TCell for the specified table, row, and column at the
+ * latest timestamp. Returns an empty list if no such value exists.
+ *
+ * @return value for specified row/column
+ */
+ list<TCell> get(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** column name */
+ 3:Text column,
+
+ /** Get attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get the specified number of versions for the specified table,
+ * row, and column.
+ *
+ * @return list of cells for specified row/column
+ */
+ list<TCell> getVer(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** column name */
+ 3:Text column,
+
+ /** number of versions to retrieve */
+ 4:i32 numVersions,
+
+ /** Get attributes */
+ 5:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get the specified number of versions for the specified table,
+ * row, and column. Only versions less than or equal to the specified
+ * timestamp will be returned.
+ *
+ * @return list of cells for specified row/column
+ */
+ list<TCell> getVerTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** column name */
+ 3:Text column,
+
+ /** timestamp */
+ 4:i64 timestamp,
+
+ /** number of versions to retrieve */
+ 5:i32 numVersions,
+
+ /** Get attributes */
+ 6:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get all the data for the specified table and row at the latest
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ */
+ list<TRowResult> getRow(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** Get attributes */
+ 3:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get the specified columns for the specified table and row at the latest
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ */
+ list<TRowResult> getRowWithColumns(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** List of columns to return, null for all columns */
+ 3:list<Text> columns,
+
+ /** Get attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get all the data for the specified table and row at the specified
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ */
+ list<TRowResult> getRowTs(
+ /** name of the table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** timestamp */
+ 3:i64 timestamp,
+
+ /** Get attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get the specified columns for the specified table and row at the specified
+ * timestamp. Returns an empty list if the row does not exist.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ */
+ list<TRowResult> getRowWithColumnsTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** List of columns to return, null for all columns */
+ 3:list<Text> columns,
+ 4:i64 timestamp,
+
+ /** Get attributes */
+ 5:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get all the data for the specified table and rows at the latest
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ */
+ list<TRowResult> getRows(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row keys */
+ 2:list<Text> rows
+
+ /** Get attributes */
+ 3:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get the specified columns for the specified table and rows at the latest
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ */
+ list<TRowResult> getRowsWithColumns(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row keys */
+ 2:list<Text> rows,
+
+ /** List of columns to return, null for all columns */
+ 3:list<Text> columns,
+
+ /** Get attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get all the data for the specified table and rows at the specified
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ */
+ list<TRowResult> getRowsTs(
+ /** name of the table */
+ 1:Text tableName,
+
+ /** row keys */
+ 2:list<Text> rows
+
+ /** timestamp */
+ 3:i64 timestamp,
+
+ /** Get attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get the specified columns for the specified table and rows at the specified
+ * timestamp. Returns an empty list if no rows exist.
+ *
+ * @return TRowResult containing the rows and map of columns to TCells
+ */
+ list<TRowResult> getRowsWithColumnsTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row keys */
+ 2:list<Text> rows
+
+ /** List of columns to return, null for all columns */
+ 3:list<Text> columns,
+ 4:i64 timestamp,
+
+ /** Get attributes */
+ 5:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Apply a series of mutations (updates/deletes) to a row in a
+ * single transaction. If an exception is thrown, then the
+ * transaction is aborted. Default current timestamp is used, and
+ * all entries will have an identical timestamp.
+ */
+ void mutateRow(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** list of mutation commands */
+ 3:list<Mutation> mutations,
+
+ /** Mutation attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Apply a series of mutations (updates/deletes) to a row in a
+ * single transaction. If an exception is thrown, then the
+ * transaction is aborted. The specified timestamp is used, and
+ * all entries will have an identical timestamp.
+ */
+ void mutateRowTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** list of mutation commands */
+ 3:list<Mutation> mutations,
+
+ /** timestamp */
+ 4:i64 timestamp,
+
+ /** Mutation attributes */
+ 5:map<Text, Text> attributes
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Apply a series of batches (each a series of mutations on a single row)
+ * in a single transaction. If an exception is thrown, then the
+ * transaction is aborted. Default current timestamp is used, and
+ * all entries will have an identical timestamp.
+ */
+ void mutateRows(
+ /** name of table */
+ 1:Text tableName,
+
+ /** list of row batches */
+ 2:list<BatchMutation> rowBatches,
+
+ /** Mutation attributes */
+ 3:map<Text, Text> attributes
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Apply a series of batches (each a series of mutations on a single row)
+ * in a single transaction. If an exception is thrown, then the
+ * transaction is aborted. The specified timestamp is used, and
+ * all entries will have an identical timestamp.
+ */
+ void mutateRowsTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /** list of row batches */
+ 2:list<BatchMutation> rowBatches,
+
+ /** timestamp */
+ 3:i64 timestamp,
+
+ /** Mutation attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Atomically increment the column value specified. Returns the next value post increment.
+ */
+ i64 atomicIncrement(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row to increment */
+ 2:Text row,
+
+ /** name of column */
+ 3:Text column,
+
+ /** amount to increment by */
+ 4:i64 value
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Delete all cells that match the passed row and column.
+ */
+ void deleteAll(
+ /** name of table */
+ 1:Text tableName,
+
+ /** Row to update */
+ 2:Text row,
+
+ /** name of column whose value is to be deleted */
+ 3:Text column,
+
+ /** Delete attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Delete all cells that match the passed row and column and whose
+ * timestamp is equal-to or older than the passed timestamp.
+ */
+ void deleteAllTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /** Row to update */
+ 2:Text row,
+
+ /** name of column whose value is to be deleted */
+ 3:Text column,
+
+ /** timestamp */
+ 4:i64 timestamp,
+
+ /** Delete attributes */
+ 5:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Completely delete the row's cells.
+ */
+ void deleteAllRow(
+ /** name of table */
+ 1:Text tableName,
+
+ /** key of the row to be completely deleted. */
+ 2:Text row,
+
+ /** Delete attributes */
+ 3:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Increment a cell by the ammount.
+ * Increments can be applied async if hbase.regionserver.thrift.coalesceIncrement is set to true.
+ * False is the default. Turn to true if you need the extra performance and can accept some
+ * data loss if a thrift server dies with increments still in the queue.
+ */
+ void increment(
+ /** The single increment to apply */
+ 1:TIncrement increment
+ ) throws (1:IOError io)
+
+
+ void incrementRows(
+ /** The list of increments */
+ 1:list<TIncrement> increments
+ ) throws (1:IOError io)
+
+ /**
+ * Completely delete the row's cells marked with a timestamp
+ * equal-to or older than the passed timestamp.
+ */
+ void deleteAllRowTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /** key of the row to be completely deleted. */
+ 2:Text row,
+
+ /** timestamp */
+ 3:i64 timestamp,
+
+ /** Delete attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get a scanner on the current table, using the Scan instance
+ * for the scan parameters.
+ */
+ ScannerID scannerOpenWithScan(
+ /** name of table */
+ 1:Text tableName,
+
+ /** Scan instance */
+ 2:TScan scan,
+
+ /** Scan attributes */
+ 3:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get a scanner on the current table starting at the specified row and
+ * ending at the last row in the table. Return the specified columns.
+ *
+ * @return scanner id to be used with other scanner procedures
+ */
+ ScannerID scannerOpen(
+ /** name of table */
+ 1:Text tableName,
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ 2:Text startRow,
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ 3:list<Text> columns,
+
+ /** Scan attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get a scanner on the current table starting and stopping at the
+ * specified rows. ending at the last row in the table. Return the
+ * specified columns.
+ *
+ * @return scanner id to be used with other scanner procedures
+ */
+ ScannerID scannerOpenWithStop(
+ /** name of table */
+ 1:Text tableName,
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ 2:Text startRow,
+
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ 3:Text stopRow,
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ 4:list<Text> columns,
+
+ /** Scan attributes */
+ 5:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Open a scanner for a given prefix. That is all rows will have the specified
+ * prefix. No other rows will be returned.
+ *
+ * @return scanner id to use with other scanner calls
+ */
+ ScannerID scannerOpenWithPrefix(
+ /** name of table */
+ 1:Text tableName,
+
+ /** the prefix (and thus start row) of the keys you want */
+ 2:Text startAndPrefix,
+
+ /** the columns you want returned */
+ 3:list<Text> columns,
+
+ /** Scan attributes */
+ 4:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get a scanner on the current table starting at the specified row and
+ * ending at the last row in the table. Return the specified columns.
+ * Only values with the specified timestamp are returned.
+ *
+ * @return scanner id to be used with other scanner procedures
+ */
+ ScannerID scannerOpenTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ 2:Text startRow,
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ 3:list<Text> columns,
+
+ /** timestamp */
+ 4:i64 timestamp,
+
+ /** Scan attributes */
+ 5:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Get a scanner on the current table starting and stopping at the
+ * specified rows. ending at the last row in the table. Return the
+ * specified columns. Only values with the specified timestamp are
+ * returned.
+ *
+ * @return scanner id to be used with other scanner procedures
+ */
+ ScannerID scannerOpenWithStopTs(
+ /** name of table */
+ 1:Text tableName,
+
+ /**
+ * Starting row in table to scan.
+ * Send "" (empty string) to start at the first row.
+ */
+ 2:Text startRow,
+
+ /**
+ * row to stop scanning on. This row is *not* included in the
+ * scanner's results
+ */
+ 3:Text stopRow,
+
+ /**
+ * columns to scan. If column name is a column family, all
+ * columns of the specified column family are returned. It's also possible
+ * to pass a regex in the column qualifier.
+ */
+ 4:list<Text> columns,
+
+ /** timestamp */
+ 5:i64 timestamp,
+
+ /** Scan attributes */
+ 6:map<Text, Text> attributes
+ ) throws (1:IOError io)
+
+ /**
+ * Returns the scanner's current row value and advances to the next
+ * row in the table. When there are no more rows in the table, or a key
+ * greater-than-or-equal-to the scanner's specified stopRow is reached,
+ * an empty list is returned.
+ *
+ * @return a TRowResult containing the current row and a map of the columns to TCells.
+ *
+ * @throws IllegalArgument if ScannerID is invalid
+ *
+ * @throws NotFound when the scanner reaches the end
+ */
+ list<TRowResult> scannerGet(
+ /** id of a scanner returned by scannerOpen */
+ 1:ScannerID id
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Returns, starting at the scanner's current row value nbRows worth of
+ * rows and advances to the next row in the table. When there are no more
+ * rows in the table, or a key greater-than-or-equal-to the scanner's
+ * specified stopRow is reached, an empty list is returned.
+ *
+ * @return a TRowResult containing the current row and a map of the columns to TCells.
+ *
+ * @throws IllegalArgument if ScannerID is invalid
+ *
+ * @throws NotFound when the scanner reaches the end
+ */
+ list<TRowResult> scannerGetList(
+ /** id of a scanner returned by scannerOpen */
+ 1:ScannerID id,
+
+ /** number of results to return */
+ 2:i32 nbRows
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Closes the server-state associated with an open scanner.
+ *
+ * @throws IllegalArgument if ScannerID is invalid
+ */
+ void scannerClose(
+ /** id of a scanner returned by scannerOpen */
+ 1:ScannerID id
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Get the regininfo for the specified row. It scans
+ * the metatable to find region's start and end keys.
+ *
+ * @return value for specified row/column
+ */
+ TRegionInfo getRegionInfo(
+ /** row key */
+ 1:Text row,
+
+ ) throws (1:IOError io)
+
+ /**
+ * Appends values to one or more columns within a single row.
+ *
+ * @return values of columns after the append operation.
+ */
+ list<TCell> append(
+ /** The single append operation to apply */
+ 1:TAppend append,
+
+ ) throws (1:IOError io)
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it adds the corresponding mutation operation for put.
+ *
+ * @return true if the new put was executed, false otherwise
+ */
+ bool checkAndPut(
+ /** name of table */
+ 1:Text tableName,
+
+ /** row key */
+ 2:Text row,
+
+ /** column name */
+ 3:Text column,
+
+ /** the expected value for the column parameter, if not
+ provided the check is for the non-existence of the
+ column in question */
+ 5:Text value
+
+ /** mutation for the put */
+ 6:Mutation mput,
+
+ /** Mutation attributes */
+ 7:map<Text, Text> attributes
+ ) throws (1:IOError io, 2:IllegalArgument ia)
+
+ /**
+ * Get the type of this thrift server.
+ *
+ * @return the type of this thrift server
+ */
+ TThriftServerType getThriftServerType()
+
+ /**
+ * Returns the cluster ID for this cluster.
+ */
+ string getClusterId()
+
+ /**
+ * Grant permissions in namespace or table level.
+ */
+ bool grant(
+ 1: required TAccessControlEntity info
+ ) throws (1: IOError io)
+
+ /**
+ * Revoke permissions in namespace or table level.
+ */
+ bool revoke(
+ 1: required TAccessControlEntity info
+ ) throws (1: IOError io)
+}
diff --git a/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift
new file mode 100644
index 0000000..ff77bf5
--- /dev/null
+++ b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift
@@ -0,0 +1,1164 @@
+/*
+ * 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.
+ */
+
+// NOTE: The "required" and "optional" keywords for the service methods are purely for documentation
+
+namespace java org.apache.hadoop.hbase.thrift2.generated
+namespace cpp apache.hadoop.hbase.thrift2
+namespace rb Apache.Hadoop.Hbase.Thrift2
+namespace py hbase
+namespace perl Hbase
+
+struct TTimeRange {
+ 1: required i64 minStamp,
+ 2: required i64 maxStamp
+}
+
+/**
+ * Addresses a single cell or multiple cells
+ * in a HBase table by column family and optionally
+ * a column qualifier and timestamp
+ */
+struct TColumn {
+ 1: required binary family,
+ 2: optional binary qualifier,
+ 3: optional i64 timestamp
+}
+
+/**
+ * Represents a single cell and its value.
+ */
+struct TColumnValue {
+ 1: required binary family,
+ 2: required binary qualifier,
+ 3: required binary value,
+ 4: optional i64 timestamp,
+ 5: optional binary tags,
+ 6: optional byte type
+}
+
+/**
+ * Represents a single cell and the amount to increment it by
+ */
+struct TColumnIncrement {
+ 1: required binary family,
+ 2: required binary qualifier,
+ 3: optional i64 amount = 1
+}
+
+/**
+ * if no Result is found, row and columnValues will not be set.
+ */
+struct TResult {
+ 1: optional binary row,
+ 2: required list<TColumnValue> columnValues,
+ 3: optional bool stale = false
+ 4: optional bool partial = false
+}
+
+/**
+ * Specify type of delete:
+ * - DELETE_COLUMN means exactly one version will be removed,
+ * - DELETE_COLUMNS means previous versions will also be removed.
+ */
+enum TDeleteType {
+ DELETE_COLUMN = 0,
+ DELETE_COLUMNS = 1,
+ DELETE_FAMILY = 2,
+ DELETE_FAMILY_VERSION = 3
+}
+
+/**
+ * Specify Durability:
+ * - SKIP_WAL means do not write the Mutation to the WAL.
+ * - ASYNC_WAL means write the Mutation to the WAL asynchronously,
+ * - SYNC_WAL means write the Mutation to the WAL synchronously,
+ * - FSYNC_WAL means Write the Mutation to the WAL synchronously and force the entries to disk.
+ */
+
+enum TDurability {
+ USE_DEFAULT = 0,
+ SKIP_WAL = 1,
+ ASYNC_WAL = 2,
+ SYNC_WAL = 3,
+ FSYNC_WAL = 4
+}
+struct TAuthorization {
+ 1: optional list<string> labels
+}
+
+struct TCellVisibility {
+ 1: optional string expression
+}
+
+/**
+ * Specify Consistency:
+ * - STRONG means reads only from primary region
+ * - TIMELINE means reads might return values from secondary region replicas
+ */
+enum TConsistency {
+ STRONG = 1,
+ TIMELINE = 2
+}
+
+/**
+ * Used to perform Get operations on a single row.
+ *
+ * The scope can be further narrowed down by specifying a list of
+ * columns or column families.
+ *
+ * To get everything for a row, instantiate a Get object with just the row to get.
+ * To further define the scope of what to get you can add a timestamp or time range
+ * with an optional maximum number of versions to return.
+ *
+ * If you specify a time range and a timestamp the range is ignored.
+ * Timestamps on TColumns are ignored.
+ */
+struct TGet {
+ 1: required binary row,
+ 2: optional list<TColumn> columns,
+
+ 3: optional i64 timestamp,
+ 4: optional TTimeRange timeRange,
+
+ 5: optional i32 maxVersions,
+ 6: optional binary filterString,
+ 7: optional map<binary, binary> attributes
+ 8: optional TAuthorization authorizations
+ 9: optional TConsistency consistency
+ 10: optional i32 targetReplicaId
+ 11: optional bool cacheBlocks
+ 12: optional i32 storeLimit
+ 13: optional i32 storeOffset
+ 14: optional bool existence_only
+ 15: optional binary filterBytes
+
+}
+
+/**
+ * Used to perform Put operations for a single row.
+ *
+ * Add column values to this object and they'll be added.
+ * You can provide a default timestamp if the column values
+ * don't have one. If you don't provide a default timestamp
+ * the current time is inserted.
+ *
+ * You can specify how this Put should be written to the write-ahead Log (WAL)
+ * by changing the durability. If you don't provide durability, it defaults to
+ * column family's default setting for durability.
+ */
+struct TPut {
+ 1: required binary row,
+ 2: required list<TColumnValue> columnValues
+ 3: optional i64 timestamp,
+ 5: optional map<binary, binary> attributes,
+ 6: optional TDurability durability,
+ 7: optional TCellVisibility cellVisibility
+}
+
+/**
+ * Used to perform Delete operations on a single row.
+ *
+ * The scope can be further narrowed down by specifying a list of
+ * columns or column families as TColumns.
+ *
+ * Specifying only a family in a TColumn will delete the whole family.
+ * If a timestamp is specified all versions with a timestamp less than
+ * or equal to this will be deleted. If no timestamp is specified the
+ * current time will be used.
+ *
+ * Specifying a family and a column qualifier in a TColumn will delete only
+ * this qualifier. If a timestamp is specified only versions equal
+ * to this timestamp will be deleted. If no timestamp is specified the
+ * most recent version will be deleted. To delete all previous versions,
+ * specify the DELETE_COLUMNS TDeleteType.
+ *
+ * The top level timestamp is only used if a complete row should be deleted
+ * (i.e. no columns are passed) and if it is specified it works the same way
+ * as if you had added a TColumn for every column family and this timestamp
+ * (i.e. all versions older than or equal in all column families will be deleted)
+ *
+ * You can specify how this Delete should be written to the write-ahead Log (WAL)
+ * by changing the durability. If you don't provide durability, it defaults to
+ * column family's default setting for durability.
+ */
+struct TDelete {
+ 1: required binary row,
+ 2: optional list<TColumn> columns,
+ 3: optional i64 timestamp,
+ 4: optional TDeleteType deleteType = 1,
+ 6: optional map<binary, binary> attributes,
+ 7: optional TDurability durability
+
+}
+
+/**
+ * Used to perform Increment operations for a single row.
+ *
+ * You can specify how this Increment should be written to the write-ahead Log (WAL)
+ * by changing the durability. If you don't provide durability, it defaults to
+ * column family's default setting for durability.
+ */
+struct TIncrement {
+ 1: required binary row,
+ 2: required list<TColumnIncrement> columns,
+ 4: optional map<binary, binary> attributes,
+ 5: optional TDurability durability
+ 6: optional TCellVisibility cellVisibility
+ 7: optional bool returnResults
+}
+
+/*
+ * Used to perform append operation
+ */
+struct TAppend {
+ 1: required binary row,
+ 2: required list<TColumnValue> columns,
+ 3: optional map<binary, binary> attributes,
+ 4: optional TDurability durability
+ 5: optional TCellVisibility cellVisibility
+ 6: optional bool returnResults
+}
+
+enum TReadType {
+ DEFAULT = 1,
+ STREAM = 2,
+ PREAD = 3
+}
+
+/**
+ * Any timestamps in the columns are ignored but the colFamTimeRangeMap included, use timeRange to select by timestamp.
+ * Max versions defaults to 1.
+ */
+struct TScan {
+ 1: optional binary startRow,
+ 2: optional binary stopRow,
+ 3: optional list<TColumn> columns
+ 4: optional i32 caching,
+ 5: optional i32 maxVersions=1,
+ 6: optional TTimeRange timeRange,
+ 7: optional binary filterString,
+ 8: optional i32 batchSize,
+ 9: optional map<binary, binary> attributes
+ 10: optional TAuthorization authorizations
+ 11: optional bool reversed
+ 12: optional bool cacheBlocks
+ 13: optional map<binary,TTimeRange> colFamTimeRangeMap
+ 14: optional TReadType readType
+ 15: optional i32 limit
+ 16: optional TConsistency consistency
+ 17: optional i32 targetReplicaId
+ 18: optional binary filterBytes
+
+}
+
+/**
+ * Atomic mutation for the specified row. It can be either Put or Delete.
+ */
+union TMutation {
+ 1: TPut put
+ 2: TDelete deleteSingle
+}
+
+/**
+ * A TRowMutations object is used to apply a number of Mutations to a single row.
+ */
+struct TRowMutations {
+ 1: required binary row
+ 2: required list<TMutation> mutations
+}
+
+struct THRegionInfo {
+ 1: required i64 regionId
+ 2: required binary tableName
+ 3: optional binary startKey
+ 4: optional binary endKey
+ 5: optional bool offline
+ 6: optional bool split
+ 7: optional i32 replicaId
+}
+
+struct TServerName {
+ 1: required string hostName
+ 2: optional i32 port
+ 3: optional i64 startCode
+}
+
+struct THRegionLocation {
+ 1: required TServerName serverName
+ 2: required THRegionInfo regionInfo
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.CompareOperator.
+ */
+enum TCompareOperator {
+ LESS = 0,
+ LESS_OR_EQUAL = 1,
+ EQUAL = 2,
+ NOT_EQUAL = 3,
+ GREATER_OR_EQUAL = 4,
+ GREATER = 5,
+ NO_OP = 6
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.regionserver.BloomType
+ */
+enum TBloomFilterType {
+/**
+ * Bloomfilters disabled
+ */
+ NONE = 0,
+ /**
+ * Bloom enabled with Table row as Key
+ */
+ ROW = 1,
+ /**
+ * Bloom enabled with Table row & column (family+qualifier) as Key
+ */
+ ROWCOL = 2,
+ /**
+ * Bloom enabled with Table row prefix as Key, specify the length of the prefix
+ */
+ ROWPREFIX_FIXED_LENGTH = 3,
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.io.compress.Algorithm
+ */
+enum TCompressionAlgorithm {
+ LZO = 0,
+ GZ = 1,
+ NONE = 2,
+ SNAPPY = 3,
+ LZ4 = 4,
+ BZIP2 = 5,
+ ZSTD = 6
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.io.encoding.DataBlockEncoding
+ */
+enum TDataBlockEncoding {
+/** Disable data block encoding. */
+ NONE = 0,
+ // id 1 is reserved for the BITSET algorithm to be added later
+ PREFIX = 2,
+ DIFF = 3,
+ FAST_DIFF = 4,
+ // id 5 is reserved for the COPY_KEY algorithm for benchmarking
+ // COPY_KEY(5, "org.apache.hadoop.hbase.io.encoding.CopyKeyDataBlockEncoder"),
+ // PREFIX_TREE(6, "org.apache.hadoop.hbase.codec.prefixtree.PrefixTreeCodec"),
+ ROW_INDEX_V1 = 7
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.KeepDeletedCells
+ */
+enum TKeepDeletedCells {
+ /** Deleted Cells are not retained. */
+ FALSE = 0,
+ /**
+ * Deleted Cells are retained until they are removed by other means
+ * such TTL or VERSIONS.
+ * If no TTL is specified or no new versions of delete cells are
+ * written, they are retained forever.
+ */
+ TRUE = 1,
+ /**
+ * Deleted Cells are retained until the delete marker expires due to TTL.
+ * This is useful when TTL is combined with MIN_VERSIONS and one
+ * wants to keep a minimum number of versions around but at the same
+ * time remove deleted cells after the TTL.
+ */
+ TTL = 2
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.TableName
+ */
+struct TTableName {
+ /** namespace name */
+ 1: optional binary ns
+ /** tablename */
+ 2: required binary qualifier
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.ColumnFamilyDescriptor
+ */
+struct TColumnFamilyDescriptor {
+ 1: required binary name
+ 2: optional map<binary, binary> attributes
+ 3: optional map<string, string> configuration
+ 4: optional i32 blockSize
+ 5: optional TBloomFilterType bloomnFilterType
+ 6: optional TCompressionAlgorithm compressionType
+ 7: optional i16 dfsReplication
+ 8: optional TDataBlockEncoding dataBlockEncoding
+ 9: optional TKeepDeletedCells keepDeletedCells
+ 10: optional i32 maxVersions
+ 11: optional i32 minVersions
+ 12: optional i32 scope
+ 13: optional i32 timeToLive
+ 14: optional bool blockCacheEnabled
+ 15: optional bool cacheBloomsOnWrite
+ 16: optional bool cacheDataOnWrite
+ 17: optional bool cacheIndexesOnWrite
+ 18: optional bool compressTags
+ 19: optional bool evictBlocksOnClose
+ 20: optional bool inMemory
+
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.TableDescriptor
+ */
+struct TTableDescriptor {
+ 1: required TTableName tableName
+ 2: optional list<TColumnFamilyDescriptor> columns
+ 3: optional map<binary, binary> attributes
+ 4: optional TDurability durability
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.NamespaceDescriptor
+ */
+struct TNamespaceDescriptor {
+1: required string name
+2: optional map<string, string> configuration
+}
+
+enum TLogType {
+ SLOW_LOG = 1,
+ LARGE_LOG = 2
+}
+
+enum TFilterByOperator {
+ AND,
+ OR
+}
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.LogQueryFilter
+ */
+struct TLogQueryFilter {
+ 1: optional string regionName
+ 2: optional string clientAddress
+ 3: optional string tableName
+ 4: optional string userName
+ 5: optional i32 limit = 10
+ 6: optional TLogType logType = 1
+ 7: optional TFilterByOperator filterByOperator = TFilterByOperator.OR
+}
+
+
+/**
+ * Thrift wrapper around
+ * org.apache.hadoop.hbase.client.OnlineLogRecordrd
+ */
+struct TOnlineLogRecord {
+ 1: required i64 startTime
+ 2: required i32 processingTime
+ 3: required i32 queueTime
+ 4: required i64 responseSize
+ 5: required string clientAddress
+ 6: required string serverClass
+ 7: required string methodName
+ 8: required string callDetails
+ 9: required string param
+ 10: required string userName
+ 11: required i32 multiGetsCount
+ 12: required i32 multiMutationsCount
+ 13: required i32 multiServiceCalls
+ 14: optional string regionName
+}
+
+//
+// Exceptions
+//
+
+/**
+ * A TIOError exception signals that an error occurred communicating
+ * to the HBase master or a HBase region server. Also used to return
+ * more general HBase error conditions.
+ */
+exception TIOError {
+ 1: optional string message
+ 2: optional bool canRetry
+}
+
+/**
+ * A TIllegalArgument exception indicates an illegal or invalid
+ * argument was passed into a procedure.
+ */
+exception TIllegalArgument {
+ 1: optional string message
+}
+
+/**
+ * Specify type of thrift server: thrift and thrift2
+ */
+enum TThriftServerType {
+ ONE = 1,
+ TWO = 2
+}
+
+enum TPermissionScope {
+ TABLE = 0,
+ NAMESPACE = 1
+}
+
+/**
+ * TAccessControlEntity for permission control
+ */
+struct TAccessControlEntity {
+ 1: required string username
+ 2: required TPermissionScope scope
+ 4: required string actions
+ 5: optional string tableName
+ 6: optional string nsName
+}
+
+service THBaseService {
+
+ /**
+ * Test for the existence of columns in the table, as specified in the TGet.
+ *
+ * @return true if the specified TGet matches one or more keys, false if not
+ */
+ bool exists(
+ /** the table to check on */
+ 1: required binary table,
+
+ /** the TGet to check for */
+ 2: required TGet tget
+ ) throws (1:TIOError io)
+
+
+ /**
+ * Test for the existence of columns in the table, as specified by the TGets.
+ *
+ * This will return an array of booleans. Each value will be true if the related Get matches
+ * one or more keys, false if not.
+ */
+ list<bool> existsAll(
+ /** the table to check on */
+ 1: required binary table,
+
+ /** a list of TGets to check for */
+ 2: required list<TGet> tgets
+ ) throws (1:TIOError io)
+
+ /**
+ * Method for getting data from a row.
+ *
+ * If the row cannot be found an empty Result is returned.
+ * This can be checked by the empty field of the TResult
+ *
+ * @return the result
+ */
+ TResult get(
+ /** the table to get from */
+ 1: required binary table,
+
+ /** the TGet to fetch */
+ 2: required TGet tget
+ ) throws (1: TIOError io)
+
+ /**
+ * Method for getting multiple rows.
+ *
+ * If a row cannot be found there will be a null
+ * value in the result list for that TGet at the
+ * same position.
+ *
+ * So the Results are in the same order as the TGets.
+ */
+ list<TResult> getMultiple(
+ /** the table to get from */
+ 1: required binary table,
+
+ /** a list of TGets to fetch, the Result list
+ will have the Results at corresponding positions
+ or null if there was an error */
+ 2: required list<TGet> tgets
+ ) throws (1: TIOError io)
+
+ /**
+ * Commit a TPut to a table.
+ */
+ void put(
+ /** the table to put data in */
+ 1: required binary table,
+
+ /** the TPut to put */
+ 2: required TPut tput
+ ) throws (1: TIOError io)
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it adds the TPut.
+ *
+ * @return true if the new put was executed, false otherwise
+ */
+ bool checkAndPut(
+ /** to check in and put to */
+ 1: required binary table,
+
+ /** row to check */
+ 2: required binary row,
+
+ /** column family to check */
+ 3: required binary family,
+
+ /** column qualifier to check */
+ 4: required binary qualifier,
+
+ /** the expected value, if not provided the
+ check is for the non-existence of the
+ column in question */
+ 5: binary value,
+
+ /** the TPut to put if the check succeeds */
+ 6: required TPut tput
+ ) throws (1: TIOError io)
+
+ /**
+ * Commit a List of Puts to the table.
+ */
+ void putMultiple(
+ /** the table to put data in */
+ 1: required binary table,
+
+ /** a list of TPuts to commit */
+ 2: required list<TPut> tputs
+ ) throws (1: TIOError io)
+
+ /**
+ * Deletes as specified by the TDelete.
+ *
+ * Note: "delete" is a reserved keyword and cannot be used in Thrift
+ * thus the inconsistent naming scheme from the other functions.
+ */
+ void deleteSingle(
+ /** the table to delete from */
+ 1: required binary table,
+
+ /** the TDelete to delete */
+ 2: required TDelete tdelete
+ ) throws (1: TIOError io)
+
+ /**
+ * Bulk commit a List of TDeletes to the table.
+ *
+ * Throws a TIOError if any of the deletes fail.
+ *
+ * Always returns an empty list for backwards compatibility.
+ */
+ list<TDelete> deleteMultiple(
+ /** the table to delete from */
+ 1: required binary table,
+
+ /** list of TDeletes to delete */
+ 2: required list<TDelete> tdeletes
+ ) throws (1: TIOError io)
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it adds the delete.
+ *
+ * @return true if the new delete was executed, false otherwise
+ */
+ bool checkAndDelete(
+ /** to check in and delete from */
+ 1: required binary table,
+
+ /** row to check */
+ 2: required binary row,
+
+ /** column family to check */
+ 3: required binary family,
+
+ /** column qualifier to check */
+ 4: required binary qualifier,
+
+ /** the expected value, if not provided the
+ check is for the non-existence of the
+ column in question */
+ 5: binary value,
+
+ /** the TDelete to execute if the check succeeds */
+ 6: required TDelete tdelete
+ ) throws (1: TIOError io)
+
+ TResult increment(
+ /** the table to increment the value on */
+ 1: required binary table,
+
+ /** the TIncrement to increment */
+ 2: required TIncrement tincrement
+ ) throws (1: TIOError io)
+
+ TResult append(
+ /** the table to append the value on */
+ 1: required binary table,
+
+ /** the TAppend to append */
+ 2: required TAppend tappend
+ ) throws (1: TIOError io)
+
+ /**
+ * Get a Scanner for the provided TScan object.
+ *
+ * @return Scanner Id to be used with other scanner procedures
+ */
+ i32 openScanner(
+ /** the table to get the Scanner for */
+ 1: required binary table,
+
+ /** the scan object to get a Scanner for */
+ 2: required TScan tscan,
+ ) throws (1: TIOError io)
+
+ /**
+ * Grabs multiple rows from a Scanner.
+ *
+ * @return Between zero and numRows TResults
+ */
+ list<TResult> getScannerRows(
+ /** the Id of the Scanner to return rows from. This is an Id returned from the openScanner function. */
+ 1: required i32 scannerId,
+
+ /** number of rows to return */
+ 2: i32 numRows = 1
+ ) throws (
+ 1: TIOError io,
+
+ /** if the scannerId is invalid */
+ 2: TIllegalArgument ia
+ )
+
+ /**
+ * Closes the scanner. Should be called to free server side resources timely.
+ * Typically close once the scanner is not needed anymore, i.e. after looping
+ * over it to get all the required rows.
+ */
+ void closeScanner(
+ /** the Id of the Scanner to close **/
+ 1: required i32 scannerId
+ ) throws (
+ 1: TIOError io,
+
+ /** if the scannerId is invalid */
+ 2: TIllegalArgument ia
+ )
+
+ /**
+ * mutateRow performs multiple mutations atomically on a single row.
+ */
+ void mutateRow(
+ /** table to apply the mutations */
+ 1: required binary table,
+
+ /** mutations to apply */
+ 2: required TRowMutations trowMutations
+ ) throws (1: TIOError io)
+
+ /**
+ * Get results for the provided TScan object.
+ * This helper function opens a scanner, get the results and close the scanner.
+ *
+ * @return between zero and numRows TResults
+ */
+ list<TResult> getScannerResults(
+ /** the table to get the Scanner for */
+ 1: required binary table,
+
+ /** the scan object to get a Scanner for */
+ 2: required TScan tscan,
+
+ /** number of rows to return */
+ 3: i32 numRows = 1
+ ) throws (
+ 1: TIOError io
+ )
+
+ /**
+ * Given a table and a row get the location of the region that
+ * would contain the given row key.
+ *
+ * reload = true means the cache will be cleared and the location
+ * will be fetched from meta.
+ */
+ THRegionLocation getRegionLocation(
+ 1: required binary table,
+ 2: required binary row,
+ 3: bool reload,
+ ) throws (
+ 1: TIOError io
+ )
+
+ /**
+ * Get all of the region locations for a given table.
+ **/
+ list<THRegionLocation> getAllRegionLocations(
+ 1: required binary table,
+ ) throws (
+ 1: TIOError io
+ )
+
+ /**
+ * Atomically checks if a row/family/qualifier value matches the expected
+ * value. If it does, it mutates the row.
+ *
+ * @return true if the row was mutated, false otherwise
+ */
+ bool checkAndMutate(
+ /** to check in and delete from */
+ 1: required binary table,
+
+ /** row to check */
+ 2: required binary row,
+
+ /** column family to check */
+ 3: required binary family,
+
+ /** column qualifier to check */
+ 4: required binary qualifier,
+
+ /** comparison to make on the value */
+ 5: required TCompareOperator compareOperator,
+
+ /** the expected value to be compared against, if not provided the
+ check is for the non-existence of the column in question */
+ 6: binary value,
+
+ /** row mutations to execute if the value matches */
+ 7: required TRowMutations rowMutations
+ ) throws (1: TIOError io)
+
+ /**
+ * Get a table descriptor.
+ * @return the TableDescriptor of the giving tablename
+ **/
+ TTableDescriptor getTableDescriptor(
+ /** the tablename of the table to get tableDescriptor*/
+ 1: required TTableName table
+ ) throws (1: TIOError io)
+
+ /**
+ * Get table descriptors of tables.
+ * @return the TableDescriptor of the giving tablename
+ **/
+ list<TTableDescriptor> getTableDescriptors(
+ /** the tablename list of the tables to get tableDescriptor*/
+ 1: required list<TTableName> tables
+ ) throws (1: TIOError io)
+
+ /**
+ *
+ * @return true if table exists already, false if not
+ **/
+ bool tableExists(
+ /** the tablename of the tables to check*/
+ 1: TTableName tableName
+ ) throws (1: TIOError io)
+
+ /**
+ * Get table descriptors of tables that match the given pattern
+ * @return the tableDescriptors of the matching table
+ **/
+ list<TTableDescriptor> getTableDescriptorsByPattern(
+ /** The regular expression to match against */
+ 1: optional string regex
+ /** set to false if match only against userspace tables */
+ 2: required bool includeSysTables
+ ) throws (1: TIOError io)
+
+ /**
+ * Get table descriptors of tables in the given namespace
+ * @return the tableDescriptors in the namespce
+ **/
+ list<TTableDescriptor> getTableDescriptorsByNamespace(
+ /** The namesapce's name */
+ 1: required string name
+ ) throws (1: TIOError io)
+
+ /**
+ * Get table names of tables that match the given pattern
+ * @return the table names of the matching table
+ **/
+ list<TTableName> getTableNamesByPattern(
+ /** The regular expression to match against */
+ 1: optional string regex
+ /** set to false if match only against userspace tables */
+ 2: required bool includeSysTables
+ ) throws (1: TIOError io)
+
+ /**
+ * Get table names of tables in the given namespace
+ * @return the table names of the matching table
+ **/
+ list<TTableName> getTableNamesByNamespace(
+ /** The namesapce's name */
+ 1: required string name
+ ) throws (1: TIOError io)
+
+ /**
+ * Creates a new table with an initial set of empty regions defined by the specified split keys.
+ * The total number of regions created will be the number of split keys plus one. Synchronous
+ * operation.
+ **/
+ void createTable(
+ /** table descriptor for table */
+ 1: required TTableDescriptor desc
+ /** rray of split keys for the initial regions of the table */
+ 2: optional list<binary> splitKeys
+ ) throws (1: TIOError io)
+
+ /**
+ * Deletes a table. Synchronous operation.
+ **/
+ void deleteTable(
+ /** the tablename to delete */
+ 1: required TTableName tableName
+ ) throws (1: TIOError io)
+
+ /**
+ * Truncate a table. Synchronous operation.
+ **/
+ void truncateTable(
+ /** the tablename to truncate */
+ 1: required TTableName tableName
+ /** whether to preserve previous splits*/
+ 2: required bool preserveSplits
+ ) throws (1: TIOError io)
+
+ /**
+ * Enalbe a table
+ **/
+ void enableTable(
+ /** the tablename to enable */
+ 1: required TTableName tableName
+ ) throws (1: TIOError io)
+
+ /**
+ * Disable a table
+ **/
+ void disableTable(
+ /** the tablename to disable */
+ 1: required TTableName tableName
+ ) throws (1: TIOError io)
+
+ /**
+ *
+ * @return true if table is enabled, false if not
+ **/
+ bool isTableEnabled(
+ /** the tablename to check */
+ 1: required TTableName tableName
+ ) throws (1: TIOError io)
+
+ /**
+ *
+ * @return true if table is disabled, false if not
+ **/
+ bool isTableDisabled(
+ /** the tablename to check */
+ 1: required TTableName tableName
+ ) throws (1: TIOError io)
+
+ /**
+ *
+ * @return true if table is available, false if not
+ **/
+ bool isTableAvailable(
+ /** the tablename to check */
+ 1: required TTableName tableName
+ ) throws (1: TIOError io)
+
+ /**
+ * Use this api to check if the table has been created with the specified number of splitkeys
+ * which was used while creating the given table. Note : If this api is used after a table's
+ * region gets splitted, the api may return false.
+ *
+ * @return true if table is available, false if not
+ *
+ * @deprecated Since 2.2.0. Because the same method in Table interface has been deprecated
+ * since 2.0.0, we will remove it in 3.0.0 release.
+ * Use {@link #isTableAvailable(TTableName tableName)} instead
+ **/
+ bool isTableAvailableWithSplit(
+ /** the tablename to check */
+ 1: required TTableName tableName
+ /** keys to check if the table has been created with all split keys */
+ 2: optional list<binary> splitKeys
+ ) throws (1: TIOError io)
+
+ /**
+ * Add a column family to an existing table. Synchronous operation.
+ **/
+ void addColumnFamily(
+ /** the tablename to add column family to */
+ 1: required TTableName tableName
+ /** column family descriptor of column family to be added */
+ 2: required TColumnFamilyDescriptor column
+ ) throws (1: TIOError io)
+
+ /**
+ * Delete a column family from a table. Synchronous operation.
+ **/
+ void deleteColumnFamily(
+ /** the tablename to delete column family from */
+ 1: required TTableName tableName
+ /** name of column family to be deleted */
+ 2: required binary column
+ ) throws (1: TIOError io)
+
+ /**
+ * Modify an existing column family on a table. Synchronous operation.
+ **/
+ void modifyColumnFamily(
+ /** the tablename to modify column family */
+ 1: required TTableName tableName
+ /** column family descriptor of column family to be modified */
+ 2: required TColumnFamilyDescriptor column
+ ) throws (1: TIOError io)
+
+ /**
+ * Modify an existing table
+ **/
+ void modifyTable(
+ /** the descriptor of the table to modify */
+ 1: required TTableDescriptor desc
+ ) throws (1: TIOError io)
+
+ /**
+ * Create a new namespace. Blocks until namespace has been successfully created or an exception is
+ * thrown
+ **/
+ void createNamespace(
+ /** descriptor which describes the new namespace */
+ 1: required TNamespaceDescriptor namespaceDesc
+ ) throws (1: TIOError io)
+
+ /**
+ * Modify an existing namespace. Blocks until namespace has been successfully modified or an
+ * exception is thrown
+ **/
+ void modifyNamespace(
+ /** descriptor which describes the new namespace */
+ 1: required TNamespaceDescriptor namespaceDesc
+ ) throws (1: TIOError io)
+
+ /**
+ * Delete an existing namespace. Only empty namespaces (no tables) can be removed.
+ * Blocks until namespace has been successfully deleted or an
+ * exception is thrown.
+ **/
+ void deleteNamespace(
+ /** namespace name */
+ 1: required string name
+ ) throws (1: TIOError io)
+
+ /**
+ * Get a namespace descriptor by name.
+ * @retrun the descriptor
+ **/
+ TNamespaceDescriptor getNamespaceDescriptor(
+ /** name of namespace descriptor */
+ 1: required string name
+ ) throws (1: TIOError io)
+
+ /**
+ * @return all namespaces
+ **/
+ list<TNamespaceDescriptor> listNamespaceDescriptors(
+ ) throws (1: TIOError io)
+
+ /**
+ * @return all namespace names
+ **/
+ list<string> listNamespaces(
+ ) throws (1: TIOError io)
+
+ /**
+ * Get the type of this thrift server.
+ *
+ * @return the type of this thrift server
+ */
+ TThriftServerType getThriftServerType()
+
+ /**
+ * Returns the cluster ID for this cluster.
+ */
+ string getClusterId()
+
+ /**
+ * Retrieves online slow RPC logs from the provided list of
+ * RegionServers
+ *
+ * @return online slowlog response list
+ * @throws TIOError if a remote or network exception occurs
+ */
+ list<TOnlineLogRecord> getSlowLogResponses(
+ /** @param serverNames Server names to get slowlog responses from */
+ 1: set<TServerName> serverNames
+ /** @param logQueryFilter filter to be used if provided */
+ 2: TLogQueryFilter logQueryFilter
+ ) throws (1: TIOError io)
+
+ /**
+ * Clears online slow/large RPC logs from the provided list of
+ * RegionServers
+ *
+ * @return List of booleans representing if online slowlog response buffer is cleaned
+ * from each RegionServer
+ * @throws TIOError if a remote or network exception occurs
+ */
+ list<bool> clearSlowLogResponses(
+ /** @param serverNames Set of Server names to clean slowlog responses from */
+ 1: set<TServerName> serverNames
+ ) throws (1: TIOError io)
+
+ /**
+ * Grant permissions in table or namespace level.
+ */
+ bool grant(
+ 1: required TAccessControlEntity info
+ ) throws (1: TIOError io)
+
+ /**
+ * Revoke permissions in table or namespace level.
+ */
+ bool revoke(
+ 1: required TAccessControlEntity info
+ ) throws (1: TIOError io)
+}
diff --git a/pom.xml b/pom.xml
index 11254c7..fa09a7e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -62,6 +62,7 @@
<module>kafka</module>
<module>spark</module>
<module>hbase-connectors-assembly</module>
+ <module>hbase-thrift</module>
</modules>
<scm>
<connection>scm:git:git://gitbox.apache.org/repos/asf/hbase-connectors.git</connection>
